int main() { Graph graph; initGraph(&graph); char input[100]; //read console input and build graph while (1) { if (fgets(input, 100, stdin)) { //fgets returns NULL at EOF (EOF in VS cmd line: enter ctrl+z enter) buildGraphFromInput(input, &graph); } else break; } //debug only buildGraphFromInput("A-BD\n", &graph); buildGraphFromInput("B-AC\n", &graph); buildGraphFromInput("C-BG\n", &graph); buildGraphFromInput("D-AEF\n", &graph); buildGraphFromInput("E-DG\n", &graph); buildGraphFromInput("F-D\n", &graph); buildGraphFromInput("G-CE\n", &graph); //traverse graph with BFS breadthFirstSearch(&graph); printf("\n"); return EXIT_SUCCESS; }
int main(int argc, char **agv) { int i; int visited[SIZE]; Graph *graph = initGraph(SIZE); printf("%d\n", sizeof(int **)); graph->edgeMat[0][1] = 1; graph->edgeMat[0][2] = 1; graph->edgeMat[1][2] = 1; graph->edgeMat[2][0] = 1; graph->edgeMat[2][3] = 1; graph->edgeMat[3][3] = 1; for(i = 0; i < graph->V; i++) { visited[i] = 0; } printf("DFS rec "); depthFirstSearch(graph, visited, 2); for(i = 0; i < graph->V; i++) { visited[i] = 0; } printf("\n DFS non_rec "); depthFirstSearchNonRec(graph, visited, 2); printf("\n BFS non_rec"); breadthFirstSearch(graph, 2); releaseGraph(graph); return 0; }
void Graph::search(SearchType searchType) { vector<Vertex *> vertexes = getVertexes(); for (vector<Vertex *>::iterator it = vertexes.begin(); it != vertexes.end(); it++) { Vertex *vertex = *it; vertex->setVisited(false); } for (vector<Vertex *>::iterator it = vertexes.begin(); it != vertexes.end(); it++) { Vertex *vertex = *it; if (!vertex->getVisited()) { switch (searchType) { case DEPTH: depthFirstSearch(vertex); break; case BREADTH: breadthFirstSearch(vertex); break; case WEIGHT: updateAllWeight(vertex); } } } }
int Master::enumerationStrategy(const Sub *s1, const Sub *s2) { switch (enumerationStrategy_) { case BestFirst: return bestFirstSearch(s1, s2); case BreadthFirst: return breadthFirstSearch(s1, s2); case DepthFirst: return depthFirstSearch(s1, s2); case DiveAndBest: return diveAndBestFirstSearch(s1, s2); default: Logger::ifout() << "Master::enumerationStrategy(): Unknown enumeration strategy\n"; OGDF_THROW_PARAM(AlgorithmFailureException, ogdf::AlgorithmFailureCode::IllegalParameter); } }
//Made by Bruno Emori (RA 88736) & Christian Nakata (RA90558) //Algoritmos em Grafos - Prof Rodrigo Calvo //Universidade Estadual de Maringá - 2016 int main() { int nVertex, nEdges, graphType, v1, v2, edgeWeight, count; fscanf(stdin, "%i", &nVertex); fscanf(stdin, "%i", &nEdges); fscanf(stdin, "%i", &graphType); if ((graphType != 0) && (graphType != 1)) { printf("Graph type must be (0) - Undirected graph, or (1) - Directed graph.\n"); return 0; } adjListBlock *adjList[nVertex]; createAdjList(adjList, nVertex); while (fscanf(stdin, "%i", &v1) != EOF) { fscanf(stdin, "%i", &v2); fscanf(stdin, "%i", &edgeWeight); insertAdjList(adjList, v1, v2, edgeWeight); if (!graphType) insertAdjList(adjList, v2, v1, edgeWeight); } printf("Number of vertices: %i.\n", nVertex); printf("Number of edges: %i.\n", nEdges); if (!graphType) printf("Graph Type: Undirected Graph\n"); else printf("Graph Type: Directed Graph\n"); printf("\nEdges:\n"); for (count = 0; count < nVertex; count++) { printf("Vertex %i: ", count); printAdjList(adjList, count); printf("\n"); } printf("\n\nDeep First Search:\n"); deepFirstSearch(adjList, nVertex); printf("\n\nBreadth First Search:\n"); breadthFirstSearch(adjList, nVertex, 0); printf("\n\nComponents:\n"); connectedComponent(adjList, nVertex); if (graphType) { printf("\n\nShortest path: (Using Dijkstra's Algorithm)\n"); dijkstra(adjList, nVertex, 0); } printf("End Program.\n"); return 0; }
int main(){ connect_to_robot(); initialize_robot(); set_origin(); set_ir_angle(LEFT, -45); set_ir_angle(RIGHT, 45); initialize_maze(); reset_motor_encoders(); int i; for (i = 0; i < 17; i++){ set_point(nodes[i]->x, nodes[i]->y); } double curr_coord[2] = {0, 0}; map(curr_coord, nodes[0]); breadthFirstSearch(nodes[0]); reversePath(nodes[16]); printPath(nodes[0]); struct point* tail = malloc(sizeof(struct point)); tail->x = nodes[0]->x; tail->y = nodes[0]->y; struct point* startpoint = tail; build_path(tail, nodes[0]); // Traverse to end node. while(tail->next){ set_point(tail->x, tail->y); // Visual display for Simulator only. tail = tail->next; } tail->next = NULL; // Final node point to null. printf("tail: X = %f Y = %f \n", tail->x, tail->y); parallel(curr_coord); spin(curr_coord, to_rad(180)); sleep(2); set_ir_angle(LEFT, 45); set_ir_angle(RIGHT, -45); mazeRace(curr_coord, nodes[0]); return 0; }
std::vector<State*> SearchTree::doSearch(std::string algorithm) { double startT, finishT; #ifdef __unix timespec startWallTime, finishWallTime; clock_gettime(CLOCK_MONOTONIC, &startWallTime); #else GET_TIME(startT); #endif std::clock_t startCpuTime = std::clock(); if (algorithm == "bcktrk") solution = backTracking(root); else if (algorithm == "dfs") solution = depthFirstSearch(dfsDepthLimit); else if (algorithm == "bfs") solution = breadthFirstSearch(); else if (algorithm == "ucs") solution = orderSearch(); else if (algorithm == "greedy") solution = greedy(); else if (algorithm == "astr") solution = AStar(); else if (algorithm == "idastr") solution = IDAStar(); searchCpuTime = (std::clock() - startCpuTime) / (double)CLOCKS_PER_SEC; #ifdef __unix clock_gettime(CLOCK_MONOTONIC, &finishWallTime); searchWallTime = (finishWallTime.tv_sec - startWallTime.tv_sec) + (finishWallTime.tv_nsec - startWallTime.tv_nsec) / 1000000000.0; #else GET_TIME(finishT); searchWallTime = finishT - startT; #endif return getPathTo(solution); }
Vector<TBLoc> shortestPath(TBLoc start, TBLoc end, const Grid<double>& world, double costFn(const TBLoc& from, const TBLoc& to, const Grid<double>& world), double heuristicFn(const TBLoc& from, const TBLoc& to, const Grid<double>& world), AlgorithmType algorithm) { // modified by Marty to use an actual Graph object ensureWorldCache(world, costFn); cout << endl; Grid<double>* const pWorld = const_cast<Grid<double>*>(&world); BasicGraph* graph = WORLD_CACHE[pWorld]; // graph->resetData(); // make the student worry about this s_world = pWorld; s_heuristicFunction = heuristicFn; // convert start/end from Loc to Vertex Vertex* startVertex = graph->getVertex(vertexName(start.row, start.col, world)); Vertex* endVertex = graph->getVertex(vertexName(end.row, end.col, world)); if (startVertex == NULL) { error(string("Graph can not find start vertex with name \"") + vertexName(start.row, start.col, world) + "\""); for (Vertex* v : graph->getVertexSet()) { cout << v->name << " "; } cout << endl; } if (endVertex == NULL) { error(string("Graph can not find end vertex with name \"") + vertexName(start.row, start.col, world) + "\""); for (Vertex* v : graph->getVertexSet()) { cout << v->name << " "; } cout << endl; } cout << "Looking for a path from " << startVertex->name << " to " << endVertex->name << "." << endl; Vector<Vertex*> result; switch (algorithm) { case BFS: cout << "Executing breadth-first search algorithm ..." << endl; result = breadthFirstSearch(*graph, startVertex, endVertex); break; case DIJKSTRA: cout << "Executing Dijkstra's algorithm ..." << endl; result = dijkstrasAlgorithm(*graph, startVertex, endVertex); break; case A_STAR: cout << "Executing A* algorithm ..." << endl; result = aStar(*graph, startVertex, endVertex); break; #ifdef BIDIRECTIONAL_SEARCH_ALGORITHM_ENABLED case BIDIRECTIONAL: cout << "Executing Bidirectional Search algorithm ..." << endl; extern Vector<Vertex*> bidirectionalSearch(BasicGraph& graph, Vertex* start, Vertex* end); result = bidirectionalSearch(*graph, startVertex, endVertex); break; #endif // BIDIRECTIONAL_SEARCH_ALGORITHM_ENABLED case DFS: default: cout << "Executing depth-first search algorithm ..." << endl; result = depthFirstSearch(*graph, startVertex, endVertex); break; } cout << "Algorithm complete." << endl; // convert Vector<Vertex*> to Vector<Loc> Vector<TBLoc> locResult; for (Vertex* v : result) { locResult.add(TBLoc(getRow(v), getCol(v))); } return locResult; }
std::list<int> Graphs::getResult() { // find solution int solution = -1; bool flag = false; for (int i = 0; i < (int) source.size(); ++i) { solution = breadthFirstSearch(GRASPcells, manip_graph, source[i], target); if (solution != -1) { flag = true; break; } } // just print source and target std::cout << "************** SOURCES **********" << std::endl; for (int i = 0; i < (int) source.size(); ++i) std::cout << " " << std::to_string(source[i]); std::cout << std::endl; std::cout << "************** TARGETS **********" << std::endl; for (int i = 0; i < (int) target.size(); ++i) std::cout << " " << std::to_string(target[i]); std::cout << std::endl; if (flag) // if there is a result { // retrieve solution int current = solution; do { result.push_back(current); current = GRASPcells[current].father; } while (current != -1); result.reverse(); // print it std::cout << "************ SOLUTION IS (GRASP Cells) *************" << std::endl; for (std::list<int>::iterator it = result.begin(); it != result.end(); ++it) { std::cout << " >> " << *it; } std::cout << std::endl; } else { std::cout << "************ THERE IS NO SOLUTION *************" << std::endl; } std::cout << std::endl << "************ Liaison edges *************" << std::endl; for (int i = 0; i < (int) GRASPManipCells.size(); ++i) { if ((int) GRASPManipCells[i].size() > 1) { for (int j = 0; j < (int) GRASPManipCells[i].size(); ++j) { std::cout << " " << GRASPManipCells[i][j]; } std::cout << std::endl; } } return result; }
int testBinarySearchTree(void) { Tree *head = NULL; Tree *singleNodeTree = malloc(sizeof(Tree)); Tree *test[2]; if(singleNodeTree == NULL) { exit(EXIT_FAILURE); } singleNodeTree->value = 100; singleNodeTree->left = NULL; singleNodeTree->right = NULL; printf("Start Test of Binary Search Tree.\n"); printf("Initial contents of the tree:\n"); print_ascii_tree(head); printf("\nadd() 5 to the tree\n"); head = addToTree(head, 5); print_ascii_tree(head); printf("\nadd() 2 to the tree\n"); head = addToTree(head, 2); print_ascii_tree(head); printf("\nadd() 12 to the tree\n"); head = addToTree(head, 12); print_ascii_tree(head); printf("\nadd() 1 to the tree\n"); head = addToTree(head, 1); print_ascii_tree(head); printf("\nadd() 8 to the tree\n"); head = addToTree(head, 8); print_ascii_tree(head); printf("\nadd() 4 to the tree\n"); head = addToTree(head, 4); print_ascii_tree(head); printf("\nadd() 3 to the tree\n"); head = addToTree(head, 3); print_ascii_tree(head); printf("\nadd() 10 to the tree\n"); head = addToTree(head, 10); print_ascii_tree(head); printf("\nadd() 9 to the tree\n"); head = addToTree(head, 9); print_ascii_tree(head); printf("\nadd() 11 to the tree\n"); head = addToTree(head, 11); print_ascii_tree(head); printf("\nadd() 7 to the tree\n"); head = addToTree(head, 7); print_ascii_tree(head); if( (test[0] = findInTree(head, 3)) == NULL) { printf("\nfind(3) = Value Not Found\n"); } else { printf("\nfind(3) = %d\n", test[0]->value); } if( (test[0] = findInTree(head, 7)) == NULL) { printf("\nfind(7) = Value Not Found\n"); } else { printf("\nfind(7) = %d\n", test[0]->value); } if( (test[0] = findInTree(head, 4)) == NULL) { printf("\nfind(4) = Value Not Found\n"); } else { printf("\nfind(4) = %d\n", test[0]->value); } findParentInTree(head, head, 3, test); if( test[1] == NULL) { printf("\nfindParentOfNode(3) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } findParentInTree(head, head, 5, test); if( test[1] == NULL) { printf("\nfindParentOfNode(5) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } findParentInTree(head, head, 2, test); if( test[1] == NULL) { printf("\nfindParentOfNode(2) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } findParentInTree(head, head, 9, test); if( test[1] == NULL) { printf("\nfindParentOfNode(9) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } printf("Depth of the tree = %d\n", getTreeDepth(head, 0)); inOrderTraversal(head); preOrderTraversal(head); postOrderTraversal(head); breadthFirstSearch(head); /* Delete Order: 1, 3, 12, 8, 5 */ printf("\nbefore removing any items\n"); print_ascii_tree(head); printf("\nremove() 1 from the tree\n"); head = removeFromTree(head, 1); print_ascii_tree(head); printf("\nremove() 3 from the tree\n"); head = removeFromTree(head, 3); print_ascii_tree(head); printf("\nremove() 12 from the tree\n"); head = removeFromTree(head, 12); print_ascii_tree(head); printf("\nremove() 8 from the tree\n"); head = removeFromTree(head, 8); print_ascii_tree(head); printf("\nremove() 5 from the tree\n"); head = removeFromTree(head, 5); print_ascii_tree(head); printf("\nremove() 11 from the tree\n"); head = removeFromTree(head, 11); print_ascii_tree(head); printf("Depth of the tree = %d\n", getTreeDepth(head, 0)); inOrderTraversal(head); breadthFirstSearch(head); printf("\nsinglNodeTests start here: \n"); print_ascii_tree(singleNodeTree); inOrderTraversal(singleNodeTree); printf("\n remove() 1 from tree\n"); if(removeFromTree(singleNodeTree, 1) == NULL) { printf("Node Not Found, nothing removed\n"); } printf("Depth of the singleNodeTree = %d\n", getTreeDepth(singleNodeTree, 0)); printf("\n remove() 100 from tree\n"); singleNodeTree = removeFromTree(singleNodeTree, 100); printf("Depth of the singleNodeTree = %d\n", getTreeDepth(singleNodeTree, 0)); return EXIT_SUCCESS; }