Ottimizzazione codice, vantaggi poo

di il
60 risposte

60 Risposte - Pagina 4

  • Re: Ottimizzazione codice, vantaggi poo

    Ma vuoi usare il mio codice o stai cercando di farne uno tuo? se vedi il codice da te proposto è differente dal mio.
  • Re: Ottimizzazione codice, vantaggi poo

    Ho dovuto modificare perchè il tuo mi univa gruppo2 in gruppo1, invece era il contrario, e poi ho dovuto anticipare lo svuota perchè cambiando it1, alla fine sbagliava a svuotare.
  • Re: Ottimizzazione codice, vantaggi poo

    it1 = mapHash.find(hash2);
    it2 = mapHash.find(hash1);
    Cambia i hash e lascia il resto com'è.
  • Re: Ottimizzazione codice, vantaggi poo

    Provato e non è quello, il problema è che quando fa il
    for (std::map<int, Gruppi *>::iterator it = mapHash.begin(); it != mapHash.end(); ++it)
    succede questo:
    it=1 it1=1 it=2
    it=it1? ok allora fai it=it2, ma cambia anche it1 che diventa come it2 quindi poi farà
    it=1 it1=2 it=2
    questo indice in mapHash è 1, dovrebbe diventare 2, ma siccome it1 è cambiato non fa la modifica
  • Re: Ottimizzazione codice, vantaggi poo

    case 'u':
    			{
    				std::string s1, s2;
    				ssin >> s1 >> s2;
    				const int hash1 = Parola::funzHash(s1);
    				const int hash2 = Parola::funzHash(s2);
    				std::map<int, Gruppi *>::const_iterator it1, it2;
    				it1 = mapHash.find(hash2);
    				it2 = mapHash.find(hash1);
    				if ((it1 != mapHash.end()) && (it2 != mapHash.end()))
    				{
    					it1->second->UnisciGruppo(*(it2->second));
    					Gruppi *g = it2->second;
    					for (std::map<int, Gruppi *>::iterator it = mapHash.begin(); it != mapHash.end(); ++it)
    					{
    						if (it->second == g)
    						{
    							it->second = it1->second;
    						}
    					}
    					g->Svuota();
    				}
    			}
    			break;
  • Re: Ottimizzazione codice, vantaggi poo

    Allora il programma è corretto. L'ho caricato e mi ha dato esito correct, quindi va bene. Peccato però perchè pensavo che lo avessimo velocizzato un po' rispetto al codice che ti ho fatto vedere ma invece mi ha tenuto il tempo vecchio.
  • Re: Ottimizzazione codice, vantaggi poo

    Puoi fare verifiche senza usare il caso unione?
  • Re: Ottimizzazione codice, vantaggi poo

    Prova questa modifica del caso unione
    case 'u':
    			{
    				std::string s1, s2;
    				ssin >> s1 >> s2;
    				const int hash1 = Parola::funzHash(s1);
    				const int hash2 = Parola::funzHash(s2);
    				std::map<int, Gruppi *>::const_iterator it1, it2;
    				it1 = mapHash.find(hash2);
    				it2 = mapHash.find(hash1);
    				if ((it1 != mapHash.end()) && (it2 != mapHash.end()))
    				{
    					it1->second->UnisciGruppo(*(it2->second));
    					Gruppi *g = it2->second;
    					std::map<int,Parola> & hashGroup = g->GetGruppo();
    					for (std::map<int, Parola>::iterator it = hashGroup.begin(); it != hashGroup.end(); ++it)
    					{
    						mapHash.find(it->first)->second = it1->second;
    					}
    					g->Svuota();
    				}
    			}
    			break;
  • Re: Ottimizzazione codice, vantaggi poo

    Correct ma sempre tempo di quello prima
  • Re: Ottimizzazione codice, vantaggi poo

    Un altra modifica
    			case 'u':
    			{
    				std::string s1, s2;
    				ssin >> s1 >> s2;
    				const int hash1 = Parola::funzHash(s1);
    				const int hash2 = Parola::funzHash(s2);
    				std::map<int, Gruppi *>::const_iterator it1, it2;
    				it1 = mapHash.find(hash2);
    				it2 = mapHash.find(hash1);
    				if ((it1 != mapHash.end()) && (it2 != mapHash.end()))
    				{
    					it1->second->UnisciGruppo(*(it2->second));
    					Gruppi *g = it2->second;
    					std::map<int,Parola> & hashGroup = g->GetGruppo();
    					for (std::map<int, Parola>::iterator it = hashGroup.begin(); it != hashGroup.end(); ++it)
    					{
    						mapHash[it->first] = it1->second;
    					}
    
    					g->Svuota();
    				}
    			}
    			break;
  • Re: Ottimizzazione codice, vantaggi poo

    Si in più ci vuole questo controllo sempre nella u:
    if ((it1 != mapHash.end()) && (it2 != mapHash.end())&&(it1->second->GetGroupID() != it2->second->GetGroupID()))
                {
    perchè altrimenti se gli do due parole che sono nello stesso gruppo, praticamente lui esegue e poi svuota, ma svuota il vettore che contiene parola1(e quindi anche parola2)
  • Re: Ottimizzazione codice, vantaggi poo

    Puoi controllare questo che è + veloce
    if(it1->second != it2->second)
  • Re: Ottimizzazione codice, vantaggi poo

    Si assolutamente, ma il mio problema è che devo recuperare 30-40sec, secondo te, a intuito da anni di esperienza che avrai più di me, ti viene in mente qualche altro metodo, intendo proprio approccio al problema? perchè io, per quanto ne so, ho provato quasi tutto. Per farlo andare più veloce di 4/5 volte vuol dire che sto facendo parecchie cose ridondanti o c'è un modo per alleggerire il tutto.
  • Re: Ottimizzazione codice, vantaggi poo

    Hai provato l'ultima modifica?
  • Re: Ottimizzazione codice, vantaggi poo

    Ho provato con
    mapHash[it->first] = it1->second;
    e
    if(it1->second != it2->second)
    ma il tempo è rimasto sempre quello vecchio. Magari domani, se hai ancora qualche carta pesante da giocare, io purtroppo non saprei dove andare a parare.
Devi accedere o registrarti per scrivere nel forum
60 risposte