C++ Graph::Copy方法代码示例

//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;
}

void
Shader::OnCommand(wxCommandEvent& evt)
{
	Project *project = Project::GetProject();
	Panel *panel;
	Undoer *undoer;
	Graph *graph;
	if (project != NULL)
	{
		panel = project->GetPanel();
		if (panel != NULL)
		{
			undoer = panel->GetUndoerCtrl();
			graph = panel->GetGraphCtrl();
		}
	}
	switch (evt.GetId())
	{
	case wxID_OPEN:
		Open();
		break;
	case wxID_SAVE:
		Save();
		break;
	case wxID_SAVEAS:
		SaveAs();
		break;
	case wxID_EXIT:
		Close(false);
		break;
	case wxID_UNDO:
		undoer->Undo();
		break;
	case wxID_REDO:
		undoer->Redo();
		break;
	case wxID_CUT:
		graph->Cut();
		break;
	case wxID_COPY:
		graph->Copy();
		break;
	case wxID_PASTE:
		graph->Paste();
		break;
	case wxID_DUPLICATE:
		graph->Duplicate();
		break;
	case wxID_GROUP:
		graph->GroupNodes();
		break;
	case wxID_UNGROUP:
		graph->UngroupNodes();
		break;
	case wxID_SAVEGROUP:
		graph->SaveGroup();
		break;
	case wxID_COPYMETAFILE:
		graph->CopyAsMetafile();
		break;
	case wxID_CONFIGURE:
		project->Configure();
		break;
	case wxID_RELOADLIBS:
		//project->ReloadLibs();
		break;
	}
}