int FindMinWeightBridge(const UndirectedGraph& graph) { vector<Color> colors(graph.Order(), WHITE); DFSVisitor visitor(graph.Order()); Edge impossible_edge(0, 0, 0, -1); DepthFirstSearch(graph, 0, impossible_edge, &colors, &visitor); return visitor.MinWeight(); }
TEST(Graph, adjaent) { UndirectedGraph graph {20}; graph.addEdge(0, 1); graph.addEdge(0, 2); graph.addEdge(0, 5); Iterator<int>* iter = graph.adjacent(0); EXPECT_EQ(5, iter->next()); EXPECT_EQ(2, iter->next()); EXPECT_EQ(1, iter->next()); }
int main(int argc, char** argv) { int i; if (argc != 2) { cout << "Spatny pocet parametru" << endl; cout << "binarka nazev-souboru" << endl; cout << std::endl << "Arguments:" << endl; exit(EXIT_FAILURE); } UndirectedGraph *graph = readGraphFromFile(argv[1]); cout << "vertex count=" << graph->vertexCount() << endl; DFSSolver *solver = new DFSSolver(graph); //time start //time_t start = time(NULL); //TimeTool(time(NULL)) start; TimeTool start(time(NULL)); //hledani reseni pair<vector<Edge> *, int> *result = solver->findBestSolution(); //time end //time_t end = time(NULL); TimeTool end(time(NULL)); vector<Edge> *solution = result->first; int solutionPrice = result->second; if (solution != NULL) { cout << "Best solution:" << endl; for (i = 0; i < solution->size(); i++) { cout << (*solution)[i] << endl; } cout << "Spanning tree degree: " << solutionPrice << endl; } //Celkovy cas vypoctu //double dif = difftime(end, start); //int h = dif/3600; //int m = dif /60; //int s = dif - (h * 3600) - (m * 60); //cout << "DIFF:" << dif << "s" << endl; //cout << "TIME:" << h << ":" << m << ":" << s << " input file " << argv[1] << endl; TimeTool dif (difftime(end.time, start.time)); //cout << "TIME: " << dif << " input file " << argv[1] << " START:" << start <<" END:" << end << endl; cout << "TIME: " << dif << " input file " << argv[1] << endl; delete graph; delete solution; delete result; delete solver; // tady to umre return 0; }
TEST_F(UndirectedGraphFixture, canBeCopied) { g_.addEdge(0, 1, 7); g_.addEdge(3, 2, 123); UndirectedGraph copy { g_ }; ASSERT_EQ(g_.getWeightOfEdge(0, 1), copy.getWeightOfEdge(0, 1)); ASSERT_EQ(g_.getWeightOfEdge(2, 3), copy.getWeightOfEdge(2, 3)); ASSERT_EQ(g_.getNumberOfEdges(), copy.getNumberOfEdges()); ASSERT_EQ(g_.getNumberOfVertices(), copy.getNumberOfVertices()); ASSERT_EQ(g_.getSumOfWeights(), copy.getSumOfWeights()); }
UndirectedGraph* GreedyHeuristic::getICTree(UndirectedGraph* t1, UndirectedGraph* t2, list<Edge*>* iset, UndirectedGraph* ug) { int cardinality = ((*t1).vertices).size() - 1; UndirectedGraph* greedyTree = new UndirectedGraph(); //cout << "iset size: " << iset->size() << endl; Edge* minE = getMinEdge(iset); greedyTree->addVertex(minE->fromVertex()); greedyTree->addVertex(minE->toVertex()); greedyTree->addEdge(minE); generateUCNeighborhoodFor(ug,minE); for (int k = 2; k < ((*ug).vertices).size(); k++) { Edge* newEdge = getICNeighbor(iset); Vertex* newVertex = NULL; if (greedyTree->contains(newEdge->fromVertex())) { newVertex = newEdge->toVertex(); } else { newVertex = newEdge->fromVertex(); } greedyTree->addVertex(newVertex); greedyTree->addEdge(newEdge); adaptUCNeighborhoodFor(newEdge,newVertex,greedyTree,ug); } if ((greedyTree->vertices).size() > (cardinality + 1)) { shrinkTree(greedyTree,cardinality); } greedyTree->setWeight(weightOfSolution(greedyTree)); return greedyTree; }
bool dfs(int v, int c, UndirectedGraph& g, int* color){ color[v] = c; for(vector<int>::iterator it=g.edge_list_begin(v); it !=g.edge_list_end(v); it++){ int dst = *it; if(color[dst] == c)return false; if(color[dst] == 0) { if(!dfs(dst, -c, g, color))return false; } } return true; }
int main(int argc, char **argv) { if (argc != 2) { std::cout << "Usage: " << argv[0] << "||||| Should be: <MAXIMUM_NUMBER_OF_VERTICES>" << std::endl; return 0; } std::cout << "The maximus number of vertices is " << argv[1] << std::endl; // Try to translate MAXIMUM_NUMBER_OF_VERTICES // to size_t in order to determine the number of vertices. try { long num_of_nodes = std::stoi(argv[1]); if (num_of_nodes < 0) { std::cout << "Invalid argument for MAXIMUM_NUMBER_OF_NODES::Must be a positive integer!::TERMINATING PROGRAM\n"; exit(1); } const size_t max_val = num_of_nodes; UndirectedGraph<size_t> testGraph; DisjointSet<size_t> testDS; size_t counter = 1; while (counter <= num_of_nodes) { testGraph.AddVertex(counter); testDS.AddNewNode(counter); ++counter; } srand(time(0)); //use current time as seed for random generator while (testDS.Size() > 1) { int i1 = rand() % max_val + 1; int i2 = rand() % max_val + 1; if (testGraph.AddEdge(i1, i2)) { testDS.Union(i1, i2); } } // testGraph.printGraph(); testGraph.PrintGraphStats(); } catch (std::invalid_argument) { std::cout << "Invalid argument for MAXIMUM_NUMBER_OF_NODES::Must be a positive integer::TERMINATING PROGRAM\n"; exit(1); } return 0; }
void GreedyHeuristic::getGreedyHeuristicResult(UndirectedGraph* aTree, int cardinality, string ls_type) { UndirectedGraph* greedyTree = new UndirectedGraph(); bool started = false; for (list<Edge*>::iterator anEdge = ((*graph).edges).begin(); anEdge != ((*graph).edges).end(); anEdge++) { greedyTree->clear(); greedyTree->addVertex((*anEdge)->fromVertex()); greedyTree->addVertex((*anEdge)->toVertex()); greedyTree->addEdge(*anEdge); generateNeighborhoodFor(*anEdge); for (int k = 1; k < cardinality; k++) { Edge* kctn = getMinNeighbor(); Vertex* nn = determineNeighborNode(kctn,greedyTree); greedyTree->addVertex(nn); greedyTree->addEdge(kctn); adaptNeighborhoodFor(kctn,nn,greedyTree); } if (!(ls_type == "no")) { /* application of local search */ if (ls_type == "leafs") { LocalSearch lsm(graph,greedyTree); lsm.run(ls_type); } else { if (ls_type == "cycles_leafs") { //cout << *greedyTree << endl; LocalSearchB lsm; lsm.run(graph,greedyTree); } } /* end local search */ /* if (!isConnectedTree(greedyTree)) { cout << "non-connected tree" << endl; } */ } greedyTree->setWeight(weightOfSolution(greedyTree)); if (started == false) { started = true; aTree->copy(greedyTree); } else { if ((greedyTree->weight()) < (aTree->weight())) { aTree->copy(greedyTree); } } } delete(greedyTree); }
int main(void) { using namespace alg; srand(time(NULL)); int NVERTEX = 10; UndirectedGraph * g = UndirectedGraph::randgraph(NVERTEX); g->printdot(); printf("Generating Kruskal's Graph: \n"); Kruskal pg(*g); pg.print(); printf("Generating Minimal spanning tree: \n"); Graph * mst = pg.run(); mst->printdot(); delete mst; delete g; return 0; }
UndirectedGraph* DirectedGraph::convertToUndirectedGraph() { UndirectedGraph* result = new UndirectedGraph(maxNodeId); for (int i = 0; i != maxNodeId + 1; i++) { if (!hasNode(i)) continue; ListType* neighborsList = inNeighborsTable[i]; for (ListType::iterator neighbor = neighborsList->begin(); neighbor != neighborsList->end(); neighbor++) { result->addEdge(*neighbor, i); } neighborsList = outNeighborsTable[i]; for (ListType::iterator neighbor = neighborsList->begin(); neighbor != neighborsList->end(); neighbor++) { result->addEdge(*neighbor, i); } } result->sort(); return result; }
int main( int argc, char **argv ) { if ( argc < 2 ) { print_help(); exit(1); } else { read_parameters(argc,argv); } // initialize random number generator rnd = new Random((unsigned) time(&t)); // initialize and read instance from file graph = new UndirectedGraph(i_file); GreedyHeuristic gho(graph); for (int i = cardb; i <= carde; i++) { cardinality = i; if ((cardinality == cardb) || (cardinality == carde) || ((cardinality % cardmod) == 0)) { Timer timer; UndirectedGraph* greedyTree = new UndirectedGraph(); if (type == "edge_based") { gho.getGreedyHeuristicResult(greedyTree,cardinality,ls); } else { if (type == "vertex_based") { gho.getVertexBasedGreedyHeuristicResult(greedyTree,cardinality,ls); } } printf("%d\t%f\t%f\n",cardinality,greedyTree->weight(),timer.elapsed_time(Timer::VIRTUAL)); delete(greedyTree); } } delete(graph); delete rnd; }
UndirectedGraph * readGraphFromFile(char * filename) { char token; int x=0, y=0, i=0; int nodes_count = 0; UndirectedGraph *graph; FILE *file = fopen(filename, (const char *)"r"); if (file == NULL) { std::cout << "Neexistujici soubor:" << filename << endl; exit(EXIT_FAILURE); } if (fscanf(file, "%d", &nodes_count) != 1) { std:cout << "Nelze nacist prvni radek vstupniho souboru" <<endl; exit(EXIT_FAILURE); } graph = new UndirectedGraph(nodes_count); while (fscanf(file, "%c", &token) == 1) { if (token == '\r') { continue; } if (token == '\n') { //printf("\n"); if (i > 0) { x=0; y++; } continue; } if(token == '1') { graph->addEdge(x,y); } x++; i++; } fclose(file); return graph; }
/** * Removes all edges from the graph except those necessary to * form a minimum cost spanning tree of all vertices using Prim's * algorithm. * * The graph must be in a state where such a spanning tree * is possible. To call this method when a spanning tree is * impossible is undefined behavior. */ UndirectedGraph UndirectedGraph::minSpanningTree() { // Define based on the Wikipedia Pseudocode UndirectedGraph nug; std::priority_queue<Edge> edges; for (vertexmap::iterator vi = this->vertices.begin(); vi != this->vertices.end(); vi++) vi->second->setVisited(false); Vertex *cur = this->vertices.begin()->second; cur->setVisited(true); for (Vertex::edgemap::iterator ei = cur->edges.begin(); ei != cur->edges.end(); ei++) edges.push(ei->second); while (!edges.empty() && nug.vertices.size() < this->vertices.size()) { Edge small = edges.top(); edges.pop(); Vertex *to = small.getTo(); if (to->wasVisited()) continue; else { to->setVisited(true); nug.addEdge(small); for (Vertex::edgemap::iterator ei = to->edges.begin(); ei != to->edges.end(); ei++) if (!ei->second.getTo()->wasVisited()) edges.push(ei->second); } } // END WHILE return nug; }
void DepthFirstSearch(const UndirectedGraph& graph, int vertex, const Edge& incoming_edge, vector<Color>* colors, DFSVisitor* visitor) { colors->at(vertex) = GREY; visitor->EnterVertex(vertex); UndirectedGraph::EdgeIterator edge; for (edge = graph.EdgesBegin(vertex); edge != graph.EdgesEnd(vertex); ++edge) { if (edge->id == incoming_edge.id) { continue; } if (colors->at(edge->head) == GREY) { visitor->BackEdge(*edge); } if (colors->at(edge->head) == WHITE) { DepthFirstSearch(graph, edge->head, *edge, colors, visitor); visitor->TreeEdge(*edge); } } colors->at(vertex) = BLACK; }
explicit ConnectedComponentsDecomposer(const UndirectedGraph<>& g) { int nVertices = g.num_vertices(); vertexToComponent_.clear(); vertexToComponent_.resize(nVertices); fill(begin(vertexToComponent_), end(vertexToComponent_), -1); int iComponent = 0; for (int i = 0; i < nVertices; ++i) { if (vertexToComponent_[i] >= 0) continue; // Lies in processed component components_.push_back(std::vector<int>()); dfs(g, {i}, [&](const GraphTraversalState& state, int index) { components_.back().push_back(index); vertexToComponent_[index] = iComponent; return IterationControl::Proceed; }); iComponent++; } }
// check whether graph is a bigraph or not with dfs bool bigraph(UndirectedGraph& g){ int num_vertex = g.get_num_vertex(); int* color = (int *)malloc(sizeof(int)*num_vertex); memset(color, 0, num_vertex*sizeof(int)); bool result = true; for(int i=0;i<num_vertex;i++){ if(color[i]==0){ if(!dfs(i, 1, g, color)){ result = false; break; } } } free(color); return result; }
TEST_F(UndirectedGraphFixture, canBeMoved) { g_.addEdge(0, 1, 7); g_.addEdge(3, 2, 123); UndirectedGraph moved { std::move(g_) }; ASSERT_EQ(7, moved.getWeightOfEdge(0, 1)); ASSERT_EQ(123, moved.getWeightOfEdge(2, 3)); ASSERT_EQ(2, moved.getNumberOfEdges()); ASSERT_EQ(5, moved.getNumberOfVertices()); ASSERT_EQ(130, moved.getSumOfWeights()); ASSERT_FALSE(g_.edgeExists(0, 1)); ASSERT_FALSE(g_.edgeExists(1, 0)); ASSERT_FALSE(g_.edgeExists(2, 3)); ASSERT_FALSE(g_.edgeExists(3, 2)); ASSERT_EQ(0, g_.getNumberOfEdges()); ASSERT_EQ(0, g_.getNumberOfVertices()); ASSERT_EQ(0, g_.getSumOfWeights()); }
UndirectedGraph* GreedyHeuristic::uniteOnCommonBase(UndirectedGraph* t1, UndirectedGraph* t2, list<Edge*>* is) { UndirectedGraph* ugh = new UndirectedGraph(); for (list<Vertex*>::iterator v = ((*t1).vertices).begin(); v != ((*t1).vertices).end(); v++) { ugh->addVertex(*v); } for (list<Vertex*>::iterator v = ((*t2).vertices).begin(); v != ((*t2).vertices).end(); v++) { if (!(ugh->contains(*v))) { ugh->addVertex(*v); } } for (list<Edge*>::iterator e = ((*t1).edges).begin(); e != ((*t1).edges).end(); e++) { ugh->addEdge(*e); } for (list<Edge*>::iterator e = ((*t2).edges).begin(); e != ((*t2).edges).end(); e++) { if (!(ugh->contains(*e))) { ugh->addEdge(*e); } else { is->push_back(*e); } } return ugh; }
inline void HexBoard::getNeighbors(const int index, vector<int> &neighbors) { board.getNeighbors(index, neighbors); }
inline HexBoardPiece HexBoard::get(const int index) { return board.getNodeValue(index); }
/** * Entry point into the netplan program. * * -Reads a file from the filesystem according to the specification for * PA3, creating an UndirectedGraph. * -Finds the total cost & ping time of the graph as presented in the input * file. * -Determines the minimum cost graph from the original graph. * -Finds the total cost & ping time of the minimum cost graph. * -Finds the change of cost & ping time from the original graph to the * minimum cost graph. * -Prints the results to stdout. * * Usage: * ./netplan infile * */ int main(int argc, char **argv) { // Data Structs to hold the variables vector<string> to; vector<string> from; vector<unsigned int> cost; vector<unsigned int> length; // if number of arguments passed in is not 2, print usage if (argc != 2) { std::cerr << "Usage: " << argv[0] << " infile" << std::endl; return EXIT_FAILURE; } std::ifstream in(argv[1]); if (!in) { std::cerr << "Unable to open file for reading." << std::endl; return EXIT_FAILURE; } // string and int variables for adding to the vectors string str; unsigned int i; /** * while file is not empty, parse input so that we can make a graph from * the input */ while(true){ in >> str; if(in.eof()) break; to.push_back(str); in >> str; from.push_back(str); in >> i; cost.push_back(i); in >> i; length.push_back(i); } /** * create undirected graph from the input file */ UndirectedGraph *bob = new UndirectedGraph(); for(unsigned int j = 0; j < to.size(); j++){ bob->addEdge(to[j], from[j], cost[j], length[j]); } // get total edge cost of inital graph unsigned int totalCost = bob->totalEdgeCost(); // get total distance of inital graph, by using Dijkstra's algorithm on // all the vertices unsigned int totalTime = bob->totalDistance(); // create minimum spanning tree of the inital graph, using Prim's algorithm bob->minSpanningTree(); // get total edge cost of minimum spanning tree unsigned int mstCost = bob->totalEdgeCost(); // get total distance of minimum spanning tree, using Dijkstra's algorithm // on all the vertices unsigned int mstTime = bob->totalDistance(); // print out all the costs and distances cout << totalCost << endl; cout << mstCost << endl; cout << totalCost - mstCost << endl; cout << totalTime << endl; cout << mstTime << endl; cout << mstTime - totalTime << endl; // delete graph delete(bob); return EXIT_SUCCESS; }
TEST(Graph, add) { UndirectedGraph graph {20}; graph.addEdge(0, 1); EXPECT_EQ(1, graph.edges()); }
int main() { cout << "--------------GRAPHTESTERFILE-----------------" << endl; cout << "CREATING GRAPH" << endl; UndirectedGraph testG = UndirectedGraph(); cout << "ADDING EDGE WITHOUT ANY VERTICES EXISTING" << endl; testG.addEdge("Yahoo","Google",13,13); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "ADDING DUPLICATE" << endl; testG.addEdge("Yahoo","Google",9,9); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "ADDING REVERSED DUPLICATE" << endl; testG.addEdge("Google","Yahoo",7,7); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "ADDING EDGE" << endl; testG.addEdge("Yahoo","Microsoft",71,71); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "ADDING UNCONNECTED EDGE" << endl; testG.addEdge("Netflix","Yelp",21,21); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "SETTING UP NON-MST" << endl; testG.addEdge("Google","Yahoo",2,2); testG.addEdge("Yahoo","Microsoft",3,3); testG.addEdge("Microsoft","Netflix",5,5); testG.addEdge("Netflix","Yelp",7,7); testG.addEdge("Yelp","Google",11,11); testG.addEdge("Netflix","Google",13,13); testG.addEdge("Google","Microsoft",17,17); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "CREATING MST" << endl; testG.minSpanningTree(); cout << "total edge cost: "; cout << testG.totalEdgeCost() << endl; cout << "TEST TOTAL DISTANCE" << endl; cout << "total distance: "; cout << testG.totalDistance("Google") << endl; cout << "TEST TOTAL DISTANCE NEW GRAPH" << endl; UndirectedGraph graphTwo = UndirectedGraph(); graphTwo.addEdge("Google","Yahoo",2,2); graphTwo.addEdge("Yahoo","Microsoft",3,3); cout << graphTwo.totalDistance("Google") << endl; cout << graphTwo.totalDistance("Yahoo") << endl; cout << graphTwo.totalDistance("Microsoft") << endl; cout << graphTwo.totalDistance() << endl; return 1; }
TEST(Graph, size) { UndirectedGraph graph {20}; EXPECT_EQ(20, graph.vertices()); }
inline double ShortestPath::pathCost() { return currGraph->getNodeValue(currEndNode); // the cost at the target node }
int main( int argc, char **argv ) { if ( argc < 2 ) { cout << "something wrong" << endl; exit(1); } else { read_parameters(argc,argv); } Timer initialization_timer; rnd = new Random((unsigned) time(&t)); graph = new UndirectedGraph(i_file); init_pheromone_trail(); register int i = 0; register int j = 0; register int k = 0; register int b = 0; cout << endl; for (int card_counter = cardb; card_counter <= carde; card_counter++) { cardinality = card_counter; if ((cardinality == cardb) || (cardinality == carde) || ((cardinality % cardmod) == 0)) { printf("begin cardinality %d\n",cardinality); if (tfile_is_given) { if (times.count(cardinality) == 1) { time_limit = times[cardinality]; } } vector<double> results; vector<double> times_best_found; double biar = 0.0; int n_of_ants = (int)(((double)((*graph).edges).size()) / ((double)cardinality)); if (n_of_ants < 15) { n_of_ants = 15; } if (n_of_ants > 50) { n_of_ants = 50; } if (ants.size() > 0) { for (list<KCT_Ant*>::iterator anAnt = ants.begin(); anAnt != ants.end(); anAnt++) { delete(*anAnt); } } ants.clear(); for (i = 0; i < n_of_ants; i++) { KCT_Ant* ant = new KCT_Ant(); ant->initialize(graph,rnd,pheromone,daemon_action); ants.push_back(ant); } for (int trial_counter = 1; trial_counter <= n_of_trials; trial_counter++) { printf("begin try %d\n",trial_counter); UndirectedGraph* best = NULL; UndirectedGraph* newSol = NULL; UndirectedGraph* restartBest = NULL; double ib_weight = 0.0; double rb_weight = 0.0; double gb_weight = 0.0; Timer timer; if ((!(card_counter == cardb)) || (!(trial_counter == 1))) { reset_pheromone_trail(); for (list<KCT_Ant*>::iterator ant = ants.begin(); ant != ants.end(); ant++) { (*ant)->restart_reset(); } } int iter = 1; double cf = 0.0; bool restart = false; bool program_stop = false; bool bs_update = false; while (program_stop == false) { for (list<KCT_Ant*>::iterator ant = ants.begin(); ant != ants.end(); ant++) { for (k = 0; k < cardinality; k++) { (*ant)->step(0.8); } (*ant)->evaluate(); } if (!(newSol == NULL)) { delete(newSol); } if (elite_action == "no") { newSol = getBestDaemonSolutionInIteration(); } else { KCT_Ant* bestAnt = getBestDaemonAntInIteration(); bestAnt->eliteAction(); newSol = new UndirectedGraph(); newSol->copy(bestAnt->getCurrentDaemonSolution()); } if (iter == 1) { best = new UndirectedGraph(); printf("best %f\ttime %f\n",newSol->weight(),timer.elapsed_time(Timer::VIRTUAL)); best->copy(newSol); restartBest = new UndirectedGraph(newSol); results.push_back(newSol->weight()); times_best_found.push_back(timer.elapsed_time(Timer::VIRTUAL)); if (trial_counter == 1) { biar = newSol->weight(); } else { if (newSol->weight() < biar) { biar = newSol->weight(); } } } else { if (restart) { restart = false; restartBest->copy(newSol); if (newSol->weight() < best->weight()) { printf("best %f\ttime %f\n",newSol->weight(),timer.elapsed_time(Timer::VIRTUAL)); best->copy(newSol); results[trial_counter-1] = newSol->weight(); times_best_found[trial_counter-1] = timer.elapsed_time(Timer::VIRTUAL); if (newSol->weight() < biar) { biar = newSol->weight(); } } } else { if (newSol->weight() < restartBest->weight()) { restartBest->copy(newSol); } if (newSol->weight() < best->weight()) { printf("best %f\ttime %f\n",newSol->weight(),timer.elapsed_time(Timer::VIRTUAL)); best->copy(newSol); results[trial_counter-1] = newSol->weight(); times_best_found[trial_counter-1] = timer.elapsed_time(Timer::VIRTUAL); if (newSol->weight() < biar) { biar = newSol->weight(); } } } } cf = get_cf(newSol); //cout << "cf: " << cf << endl; if (bs_update && (cf > 0.99)) { //cout << "doing restart" << endl; bs_update = false; restart = true; cf = 0.0; reset_pheromone_trail(); } else { if (cf > 0.99) { bs_update = true; } if (!bs_update) { if (cf < 0.7) { l_rate = 0.15; ib_weight = 2.0/3.0; rb_weight = 1.0/3.0; gb_weight = 0.0; } if ((cf >= 0.7) && (cf < 0.95)) { l_rate = 0.1; ib_weight = 1.0 / 3.0; rb_weight = 2.0 / 3.0; gb_weight = 0.0; } if (cf >= 0.95) { l_rate = 0.05; ib_weight = 0.0; rb_weight = 1.0; gb_weight = 0.0; } } else { // if bs_update = TRUE we use the best_so_far solution for updating the pheromone values l_rate = 0.1; ib_weight = 0.0; rb_weight = 0.0; gb_weight = 1.0; } map<Edge*,double>* trans_best = translate_solution(best); map<Edge*,double>* trans_newSol = translate_solution(newSol); map<Edge*,double>* trans_restartBest = translate_solution(restartBest); map<Edge*,double>* new_pd = new map<Edge*,double>; for (list<Edge*>::iterator e = (graph->edges).begin(); e != (graph->edges).end(); e++) { (*new_pd)[*e] = 0.0; (*new_pd)[*e] = (*new_pd)[*e] + (ib_weight * (*trans_newSol)[*e]) + (rb_weight * (*trans_restartBest)[*e]) + (gb_weight * (*trans_best)[*e]); } for (list<Edge*>::iterator e = (graph->edges).begin(); e != (graph->edges).end(); e++) { (*pheromone)[*e] = (*pheromone)[*e] + (l_rate * ((*new_pd)[*e] - (*pheromone)[*e])); if ((*pheromone)[*e] > tau_max) { (*pheromone)[*e] = tau_max; } if ((*pheromone)[*e] < tau_min) { (*pheromone)[*e] = tau_min; } } delete(trans_best); delete(trans_newSol); delete(trans_restartBest); delete(new_pd); } for (list<KCT_Ant*>::iterator i = ants.begin(); i != ants.end(); i++) { (*i)->reset(); } iter = iter + 1; if (tfile_is_given) { if (timer.elapsed_time(Timer::VIRTUAL) > time_limit) { program_stop = true; } } else { if (time_limit_given && iter_limit_given) { if ((timer.elapsed_time(Timer::VIRTUAL) > time_limit) || (iter > n_of_iter)) { program_stop = true; } } else { if (time_limit_given) { if (timer.elapsed_time(Timer::VIRTUAL) > time_limit) { program_stop = true; } } else { if (iter > n_of_iter) { program_stop = true; } } } } } printf("end try %d\n",trial_counter); // eturetken 18.09.09. Write the best MST for this cardinality to the file. //////////////////////////////////////////////////////////////////// if( mstfile_is_given ) { string MSTFile(mst_file); best->Write2File(concatIntToString(MSTFile, card_counter) + ".mst"); } //////////////////////////////////////////////////////////////////// delete(best); delete(restartBest); delete(newSol); } double r_mean = 0.0; double t_mean = 0.0; for (int i = 0; i < results.size(); i++) { r_mean = r_mean + results[i]; t_mean = t_mean + times_best_found[i]; } r_mean = r_mean / ((double)results.size()); t_mean = t_mean / ((double)times_best_found.size()); double rsd = 0.0; double tsd = 0.0; for (int i = 0; i < results.size(); i++) { rsd = rsd + pow(results[i]-r_mean,2.0); tsd = tsd + pow(times_best_found[i]-t_mean,2.0); } rsd = rsd / ((double)(results.size()-1.0)); if (rsd > 0.0) { rsd = sqrt(rsd); } tsd = tsd / ((double)(times_best_found.size()-1.0)); if (tsd > 0.0) { tsd = sqrt(tsd); } if (output_file_given == true) { fout << cardinality << "\t" << r_mean << "\t" << rsd << "\t" << t_mean << "\t" << tsd << endl; } else { printf("statistics\t%d\t%g\t%f\t%f\t%f\t%f\n",cardinality,biar,r_mean,rsd,t_mean,tsd); } printf("end cardinality %d\n",cardinality); } } if (output_file_given == true) { fout.close(); } delete(graph); delete rnd; }