Ottimizzazione codice, vantaggi poo

di Anonimizzato14672 il
60 risposte

60 Risposte - Pagina 4

  • /
    Anonimizzato7532
    Utente anonimizzato
    Ma vuoi usare il mio codice o stai cercando di farne uno tuo? se vedi il codice da te proposto è differente dal mio.
  • /
    Anonimizzato14672
    Utente anonimizzato
    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.
  • /
    Anonimizzato7532
    Utente anonimizzato
    it1 = mapHash.find(hash2);
it2 = mapHash.find(hash1);
    Cambia i hash e lascia il resto com'è.
  • /
    Anonimizzato14672
    Utente anonimizzato
    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
  • /
    Anonimizzato7532
    Utente anonimizzato
    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;
  • /
    Anonimizzato14672
    Utente anonimizzato
    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.
  • /
    Anonimizzato7532
    Utente anonimizzato
    Puoi fare verifiche senza usare il caso unione?
  • /
    Anonimizzato7532
    Utente anonimizzato
    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;
  • /
    Anonimizzato14672
    Utente anonimizzato
    Correct ma sempre tempo di quello prima
  • /
    Anonimizzato7532
    Utente anonimizzato
    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;
  • /
    Anonimizzato14672
    Utente anonimizzato
    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)
  • /
    Anonimizzato7532
    Utente anonimizzato
    Puoi controllare questo che è + veloce 
    if(it1->second != it2->second)
  • /
    Anonimizzato14672
    Utente anonimizzato
    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.
  • /
    Anonimizzato7532
    Utente anonimizzato
    Hai provato l'ultima modifica?
  • /
    Anonimizzato14672
    Utente anonimizzato
    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