vector<Persistivel*> PersisteMemoriaPessoa::carregarCadastros(const int id)
{
vector<Persistivel*> vLista;
Lista<Persistivel*>* lista = Sistema::getListaPessoas()->getLista();
if (lista->tamanho() > 0)
{
Persistivel_local* persistivel_local = new Persistivel_local();
Lista<Persistivel*>::Iterator it;
it = lista->begin();
while(it != lista->end())
{
persistivel_local = static_cast<Persistivel_local*>( *it );
if (id > 0 && persistivel_local->getId() == id)
{
vLista.push_back( static_cast<Persistivel*>(persistivel_local) );
return vLista;
}
else if (id < 0)
{
vLista.push_back(persistivel_local);
}
it++;
}
}
return vLista;
}
void Bola::colidiu(Lista<Bloco> &blocos,Fila<Buff> &buffs,Player &jogador,Pilha<sf::Color> &pilha){
for(Lista<Bloco>::iterator i=blocos.begin();i!=blocos.end();i++){
if(this->getGlobalBounds().intersects(i->getGlobalBounds())){
laser1.play();
if(this->getPosition().y>i->getPosition().y&&this->getPosition().y<i->getPosition().y+25){
speed.x*=-1;
}else speed.y*=-1;
--(*i);
//Olhar essa parte
///Mesmo sem quebrar o bloco, a pilha é alterada
if(!pilha.empty()){
if(i->getFillColor()==pilha.top())
pilha.pop();
else
pilha.push(i->getFillColor());
}
if(i->getLife()==0){
jogador.setPontos(jogador.getPontos()+10*i->getType());
if(i->hasBuff){
if(!buffs.front().isActive){
buffs.front().isActive=true;
buffs.front().setPosition(i->getPosition());
}
}
i=blocos.erase(i);
}
}
}
}
int main()
{
int iPuntuacion = 0, iNumCorte = 0;
string Entrada;
Lista Jugadores;
while( cin >> Entrada >> iPuntuacion ) {
if( Entrada == "corte" ) {
iNumCorte++;
for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
if( it->second.first < iPuntuacion && it->second.second == 0 ) {
it->second.second = iNumCorte;
}
}
} else {
if( iNumCorte == 0 ) {
Jugadores[Entrada].first += iPuntuacion;
} else {
if( Jugadores.find( Entrada ) == Jugadores.end() ) {
cout << Entrada << "?" << endl;
} else {
if( Jugadores[Entrada].second != 0 ) {
cout << Entrada << " OUT" << endl;
} else {
Jugadores[Entrada].first += iPuntuacion;
}
}
}
}
}
vector<Pareja> Ordenar;
for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
Ordenar.push_back( Pareja(it->second.first, it->first) );
}
sort( Ordenar.begin(), Ordenar.end(), Comparar );
for( int i = 0; i < int(Ordenar.size()); i++ ) {
if( Jugadores[Ordenar[i].second].second == 0 )
cout << "** " << Ordenar[i].second << " " << Ordenar[i].first << endl;
else
cout << "C" << Jugadores[Ordenar[i].second].second << " " << Ordenar[i].second << " " << Ordenar[i].first << endl;
}
return 0;
}
vector<Par> MaxEmparejamiento() {
fill(pareja.begin(), pareja.end(), -1);
for (int i = 0; i < n; ++i) {
if (!lado[i]) continue; CaminoIncremental(i);
fill(visitado.begin(), visitado.end(), false);
}
vector<Par> pares;
for (int i = 0; i < n; ++i)
if (!lado[i] && pareja[i] != -1)
pares.push_back(Par(pareja[i], i));
return pares; // Cardinalidad = pares.size()
}
Flujo AumentarFlujo(int s, int t) {
fill(padre.begin(), padre.end(), -1);
queue<int> q; q.push(s); padre[s] = s;
while (!q.empty()) {
int u = q.front();
q.pop(); if (u == t) break;
for (int i = 0; i < aristas[u].size(); ++i) {
int v = aristas[u][i];
if (flujo[u][v] == cap[u][v] ||
padre[v] != -1) continue;
padre[v] = u, q.push(v);
}
}
if (padre[t] == -1) return 0;
return ActualizarFlujo(t, FINF);
}
Flujo Dinic( int s, int t ){
Flujo flujo_maximo = dist[t] = 0;
while( dist[t] < INT_MAX){
fill( dist.begin(), dist.end(), INT_MAX );
queue<int> q; q.push(s); dist[s] = 0;
while( !q.empty() ){
int u = q.front(); q.pop();
for( int i = 0; i < aristas[u].size(); i++ ){
int v = aristas[u][i];
if( flujo[u][v] == cap[u][v] || dist[v] <= dist[u] + 1 ) continue;
dist[v] = dist[u] + 1, q.push(v);
}
}
if( dist[t] < INT_MAX ) flujo_maximo += FlujoBloqueante( s, t, FINF );
}
return flujo_maximo;
}
Flujo Dinic( int s, int t ){
Flujo flujo_maximo = dist[t] = 0;
while( dist[t] < INT_MAX ){
fill( dist.begin(), dist.end(), INT_MAX );
queue<int> q; q.push(s); dist[s] = 0;
while( !q.empty() ){
int u = q.front(); q.pop();
for( int i = 0; i < aristas[u].size(); i++ ){
AristaFlujo* v = aristas[u][i];
if( dist[v->dst] < INT_MAX )continue;
if( v->flujo == v->cap )continue;
dist[v->dst] = dist[u] + 1;
q.push( v->dst );
}
}
if( dist[t] < INT_MAX )
flujo_maximo += FlujoBloqueante( s, t, FINF );
}
return flujo_maximo;
}
int _tmain(int argc, _TCHAR* argv[])
{
cout << "-------Probando con Int-------" << endl;
Lista<int> numInt;
for (int i = 0; i < 5; ++i) {
numInt.insertarAlFrente(i);
numInt.imprimir();
}
numInt.eliminarDelMedio(2);
numInt.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<int> it = numInt.begin();
while (it != numInt.end()) {
cout << *it << endl;
++it;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<int> it2 = numInt.rbegin();
while (it2 != numInt.rend()) {
cout << *it2 << endl;
++it2;
}
cout << "-------Probando con Double-------" << endl;
Lista<double> numDou;
for (int i = 0; i < 5; ++i) {
numDou.insertarAlFrente(i/2.22);
numDou.imprimir();
}
numDou.eliminarDelMedio(2);
numDou.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<double> it3 = numDou.begin();
while (it3 != numDou.end()) {
cout << *it3 << endl;
++it3;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<double> it4 = numDou.rbegin();
while (it4 != numDou.rend()) {
cout << *it4 << endl;
++it4;
}
cout << "-------Probando con Char-------" << endl;
Lista<char> numChar;
for (char i = 'a'; i < 'a' + 5; ++i) {
numChar.insertarAlFrente(i);
numChar.imprimir();
}
numChar.eliminarDelMedio(2);
numChar.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<char> it5 = numChar.begin();
while (it5 != numChar.end()) {
cout << *it5 << endl;
++it5;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<char> it6 = numChar.rbegin();
while (it6 != numChar.rend()) {
cout << *it6 << endl;
++it6;
}
cout << "-------Probando con Clase Persona-------" << endl;
Lista<Persona> numPersona;
Persona p1("Arbol", "1");
Persona p2("Hoja", "2");
Persona p3("Zeta", "3");
numPersona.insertarAlFinal(p2);
numPersona.imprimir();
numPersona.insertarAlFinal(p1);
numPersona.imprimir();
numPersona.insertarAlFinal(p3);
numPersona.imprimir();
numPersona.insertarAlFinal(p3);
numPersona.imprimir();
numPersona.insertarAlFinal(p2);
numPersona.imprimir();
numPersona.insertarAlFinal(p1);
numPersona.imprimir();
numChar.eliminarDelMedio(2);
numChar.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<Persona> it7 = numPersona.begin();
while (it7 != numPersona.end()) {
cout << *it7 << endl;
++it7;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<Persona> it8 = numPersona.rbegin();
while (it8 != numPersona.rend()) {
cout << *it8 << endl;
++it8;
}
system("pause");
return 0;
}
vector<Par> EmparejamientoOptimo() {
fill(pareja.begin(), pareja.end(), -1);
fill(etiqueta.begin(), etiqueta.end(), 0);
for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j)
etiqueta[i] = max(etiqueta[i], costo[i][j]);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
slack[j + n] = etiqueta[i] +
etiqueta[j + n] - costo[i][j];
fill(visitado.begin(), visitado.end(), false);
fill(retorno.begin(), retorno.end(), i);
visitado[i] = true;
bool emparejado = false;
for (int j = 0; !emparejado; ++j) {
int t = n; for (; t < 2 * n; ++t) {
if (visitado[t]) continue;
if (Igual(slack[t], 0)) break;
}
if (t < 2 * n) {
visitado[t] = true;
if (pareja[t] == -1) {
emparejado = true;
for (int p; ; t = p) {
pareja[t] = retorno[t];
p = pareja[retorno[t]];
pareja[retorno[t]] = t;
if (retorno[t] == i) break;
}
} else {
visitado[t = pareja[t]] = true;
for (int k = 0; k < n; ++k) {
Costo new_slack = etiqueta[t] +
etiqueta[k + n] - costo[t][k];
if (!Igual(new_slack, slack[k + n])
&& new_slack < slack[k + n]) {
slack[k + n] = new_slack;
retorno[k + n] = t;
}
}
}
} else {
Costo d = CINF;
for (int k = n; k < 2 * n; ++k)
if (!Igual(slack[k], 0))
d = min(d, slack[k]);
for (int k = 0; k < n; ++k)
if (visitado[k]) etiqueta[k] -= d;
for (int k = n; k < 2 * n; ++k)
if (!visitado[k]) slack[k] -= d;
else etiqueta[k] += d;
}
}
}
vector<Par> pares;
for (int i = 0; i < n; ++i)
if (!Igual(costo[i][pareja[i] - n], s * -CINF))
pares.push_back(Par(i, pareja[i] - n));
return pares; // Emparejamiento optimo.
}
