C++ Collection::Destroy方法代码示例

//El algoritmo toma como entrada el grafo factible solucion encontrado.
//Retorna el grafo solucion optimizado mediante busqueda local basada en key-paths.
Graph* KeyPathLocalSearch::KeyPathLS(Graph *graph){
	
	//Hago una copia para trabajar en el algoritmo
	Graph * gsol = graph->Copy();
	
	bool improve = true; 
	//seteo la semilla
	srand((unsigned)time(0));
	//genero el grafo original antes de la construccion greedy
	Graph *G = gsol->Copy();
	G->EnableAll();
	Path *p, *shortest;
	int index,x,y;
	Collection *nodes;
	
	//buscamos soluciones vecinas analizando cada key-path en gsol y remplazando
	//los mismos por otro para mejorar los costos sin perder la factibilidad.
	while (improve){
		improve = false;
		//descomposicion en key-paths del grafo
		Collection *K = KeyPathDecomp(gsol);
		//genero coleccion de flags para marcar key-paths ya analizados
		Collection *analized = new Collection();
		for (int i = 0; i<K->Size(); i++)
			analized->Add((Object*) new Boolean(false));
			
		
		while (not(improve) and NotAnalizedKP(analized)){
			//sorteo key-path a analizar
			index = GetRandomIndex(analized);
			((Boolean*)analized->GetItem(index))->SetValue(true);
			//obtengo el key-path a analizar
			p = (Path*)K->GetItem(index); 
			//quito del grafo original los nodos del grafo solucion y las aristas adyacentes
			Graph *mu = G->Copy();
			Collection *enabled = gsol->GetEnabledNodes();
			mu->Rest(enabled);
			enabled->Destroy(); 
			nodes = mu->GetEnabledNodes();
			//habilito los nodos del key-path examinado y las aristas correspondientes
			for(int ind = 0; ind < p->Length(); ind++){
				mu->EnableNode(p->GetNode(ind)); 
				x = p->GetNode(ind);
				for (int j = 0; j<nodes->Size(); j++){
					y = ((Integer*)nodes->GetItem(j))->GetValue();
					if (mu->ExistEdge(x,y))
						mu->EnableEdge(x,y);
				}
			}
			nodes->Destroy();
			for(int ind = 0; ind < p->Length()-1; ind++)
				mu->EnableEdge(p->GetNode(ind),p->GetNode(ind+1));				
			//obtengo el camino mas corto entre los extremos del key-path
			shortest = Algorithms::Dijkstra(mu,p->GetNode(0),p->GetNode(p->Length()-1));
			if (shortest != NULL){
				//comparo los costos
				if((shortest->GetCost()) < (p->GetCost())){
					//quito los nodos del key-path del grafo solucion y sus aristas adyacentes, los extremos los dejo
					if (p->Length() > 2){
						for(int ind = 1; ind < p->Length()-1; ind++){
							Collection * adyacents = gsol->GetAdyacents(p->GetNode(ind));
							for (int j = 0; j < adyacents->Size(); j++)
								gsol->DisableEdge(p->GetNode(ind),((Integer*)adyacents->GetItem(j))->GetValue());
							gsol->DisableNode(p->GetNode(ind)); 
							adyacents->Destroy();
						}
					}
					else //key-path de dos nodos
						gsol->DisableEdge(p->GetNode(0),p->GetNode(1));
					//agrego los nodos del camino mas corto encontrado y las aristas de este, los extremos ya estan
					for (int ind = 0; ind < shortest->Length()-1; ind++){
						x = shortest->GetNode(ind);
						y = shortest->GetNode(ind+1);
						if (gsol->ExistEdge(x,y))
							gsol->EnableEdge(x,y);
						gsol->EnableNode(x);
						gsol->EnableNode(y); 
					}
					//encontre una mejora para el grafo solucion
					improve = true;
				}
			}
			delete shortest;
			delete mu;
		}
		analized->Destroy();
		K->Destroy();
	}
	delete G;
	return gsol;
}

//Retorna la descomposicion en key-path del grafo pasado por parametro
Collection* KeyPathLocalSearch::KeyPathDecomp(Graph *g){
	
		Graph *grafo = g->Copy();
		Collection *K = new Collection();
		//nodos que pueden ser extremos de los key-path, son terminales o key-nodes
		Collection * terminals =  g->GetTerminals();
		Collection * key_nodes = g->GetKeyNodes(true);
		Collection * end_nodes = terminals->Union(key_nodes);
		
		int node, currentNode, lastIdentifier, degree;
		bool isTerminal, isKeyNode;
		
		//para cada posible nodo extremo de key-path
		for (int i=0; i<end_nodes->Size(); i++){
			node = ((Integer*)end_nodes->GetItem(i))->GetValue();
			Collection * end_node_adyacents = grafo->GetAdyacents(node);
			//para cada adyacente al nodo extremo
			for (int j = 0; j < end_node_adyacents->Size(); j++){
				lastIdentifier = node;
				//creo el camino
				Path * aux = new Path(g);
				//agrego el extremo
				aux->Add(node);
				//calculo el nodo siguiente del camino
				currentNode = ((Integer*)end_node_adyacents->GetItem(j))->GetValue();
				degree = grafo->GetNodeDegree(currentNode);
				if (grafo->IsNodeEnabled(currentNode) && degree != 0){
					do
					{
						//agrego nodo al camino
						aux->Add(currentNode);
						Collection * adyacents = grafo->GetAdyacents(currentNode);
						//calculo si es terminal y si es key-node
						isTerminal = g->IsTerminal(currentNode);
						isKeyNode = g->IsKeyNode(currentNode);
						//si es nodo intermedio actualizo el currentNode
						if(! isTerminal && ! isKeyNode){
							if(((Integer*)adyacents->GetItem(0))->GetValue() == lastIdentifier){
								lastIdentifier = currentNode;
								currentNode = ((Integer*)adyacents->GetItem(1))->GetValue();
							}
							else{
								lastIdentifier = currentNode;
								currentNode = ((Integer*)adyacents->GetItem(0))->GetValue();
							}
						}
						adyacents->Destroy();
					}while(! isTerminal && ! isKeyNode); //mientras este en nodos intermedios
					K->Add((Object*)aux);
					//apago aristas y nodos del path, dejo prendidos los extremos
					if (aux->Length() > 2)
					{
						for (int ind=1; ind<aux->Length()-1; ind++){
							Collection *adyacents = grafo->GetAdyacents(aux->GetNode(ind));
							//apago aristas si es que existen
							for (int iter=0; iter<adyacents->Size();iter++){
								if (grafo->ExistEdge(aux->GetNode(ind),((Integer*)adyacents->GetItem(iter))->GetValue()))
									grafo->DisableEdge(aux->GetNode(ind),((Integer*)adyacents->GetItem(iter))->GetValue());
							}
							grafo->DisableNode(aux->GetNode(ind));	
							adyacents->Destroy();
						}
					}
					else //key-path de dos nodos
					{
						grafo->DisableEdge(aux->GetNode(0),aux->GetNode(1));
					}
				}
				else{
					delete aux;
				}
			}
			end_node_adyacents->Destroy();
		}
		terminals->Destroy();
		key_nodes->Destroy();
		delete end_nodes;
		delete grafo;
		return K;
}