/* ----------------------------------------- * This is the node state BEFORE the search is initiated. * 1. initialize node_state_ with adjList all uncolored * 2. Does pre-coloring * ---------------------------------------*/ Node::Node(bool isRoot, int n, CProxy_Node parent) : nodeID_("0"), parent_(parent), uncolored_num_(n), is_root_(isRoot), child_num_(0), child_finished_(0), child_succeed_(0), is_and_node_(false), parentBits(1), parentPtr(NULL) { __sdag_init(); programStart = CkTimer(); CkAssert(isRoot); vertex v = vertex(chromaticNum_); node_state_ = std::vector<vertex>(vertices_, v); //preColor(); #ifdef DEBUG CkPrintf("After Precolor\n"); printGraph(); #endif int count = uncolored_num_; uncolored_num_ -= vertexRemoval(); CkPrintf("Vertices removed by vertex removal in [MainChare] = %d\n", count-uncolored_num_); #ifdef DEBUG CkPrintf("Vertex Removal\n"); printGraph(); #endif CProxy_counter(counterGroup).ckLocalBranch()->registerMe(nodeID_); run(); }
int main() { int ver = 8; graph *g; g = initGraph(ver); addEdge(g, 0, 7); addEdge(g, 0, 4); addEdge(g, 1, 3); addEdge(g, 1, 2); addEdge(g, 2, 1); addEdge(g, 2, 3); addEdge(g, 3, 0); addEdge(g, 3, 4); addEdge(g, 4, 5); addEdge(g, 5, 7); addEdge(g, 6, 5); addEdge(g, 7, 6); addEdge(g, 7, 4); printGraph(g); dfsinit(g, 2); printGraph(g); }
int main() { struct Graph *graph = NULL; struct Graph *Dijkstra_Graph = NULL; int V=5; /// create array graph = CreateGraph(V); addEdge(graph, 0, 1,1); addEdge(graph, 0, 4,2); addEdge(graph, 1, 2,2); addEdge(graph, 1, 3,3); addEdge(graph, 1, 4,5); addEdge(graph, 2, 3,1); addEdge(graph, 3, 4,4); //printf("Enter value"); printGraph(graph); printf("Dijkstra Algorithm\n"); Dijkstra_Graph = CreateGraph(V); // print the adjacency list representation of the above graph dijkstra_algorithm(graph , Dijkstra_Graph); printGraph(Dijkstra_Graph); return 0; }
int main(int argc, char* argv[]){ int i, n=8; List S = newList(); Graph G = newGraph(n); Graph T=NULL, C=NULL; for(i=1; i<=n; i++) append(S, i); addArc(G, 1,2); addArc(G, 1,5); addArc(G, 2,5); addArc(G, 2,6); addArc(G, 3,2); addArc(G, 3,4); addArc(G, 3,6); addArc(G, 3,7); addArc(G, 3,8); addArc(G, 6,5); addArc(G, 6,7); addArc(G, 8,4); addArc(G, 8,7); printGraph(stdout, G); DFS(G, S); fprintf(stdout, "\n"); fprintf(stdout, "x: d f p\n"); for(i=1; i<=n; i++){ fprintf(stdout, "%d: %2d %2d %2d\n", i, getDiscover(G, i), getFinish(G, i), getParent(G, i)); } fprintf(stdout, "\n"); printList(stdout, S); fprintf(stdout, "\n"); T = transpose(G); C = copyGraph(G); fprintf(stdout, "\n"); printGraph(stdout, C); fprintf(stdout, "\n"); printGraph(stdout, T); fprintf(stdout, "\n"); DFS(T, S); fprintf(stdout, "\n"); fprintf(stdout, "x: d f p\n"); for(i=1; i<=n; i++){ fprintf(stdout, "%d: %2d %2d %2d\n", i, getDiscover(T, i), getFinish(T, i), getParent(T, i)); } fprintf(stdout, "\n"); printList(stdout, S); fprintf(stdout, "\n"); freeList(&S); freeGraph(&G); freeGraph(&T); freeGraph(&C); return(0); }
int main(int argc, char* argv[]){ // Parameters char fileNameGp[1024]; // Name of the file that contains the pattern graph char fileNameGt[1024]; // Name of the file that contains the target graph int timeLimit=60; // Default: CPU time limit set to 60 seconds int verbose = 0; // Default: non verbose execution bool induced = false; // Default: search for partial subgraph bool firstSol = false; // Default: search for all solutions bool isLabelled = false; // Default: non labelled graphs fileNameGp[0] = 0; fileNameGt[0] = 0; parse(&isLabelled, &timeLimit, &firstSol, &induced, &verbose, fileNameGp, fileNameGt, argv, argc); if (verbose >= 2) printf("Parameters: isLabelled=%d induced=%d firstSol=%d timeLimit=%d verbose=%d fileNameGp=%s fileNameGt=%s\n", isLabelled, induced,firstSol,timeLimit,verbose,fileNameGp,fileNameGt); // Initialize graphs Tgraph *Gp = createGraph(fileNameGp, isLabelled); // Pattern graph Tgraph *Gt = createGraph(fileNameGt, isLabelled); // Target graph if (verbose >= 2){ printf("Pattern graph:\n"); printGraph(Gp); printf("Target graph:\n"); printGraph(Gt); } // Initialize domains Tdomain *D = createDomains(Gp, Gt); if (!initDomains(induced, D, Gp, Gt)) return printStats(false); if (verbose >= 2) printDomains(D, Gp->nbVertices); // Check the global all different constraint if ((!updateMatching(Gp->nbVertices,Gt->nbVertices,D->nbVal,D->firstVal,D->val,D->globalMatchingP)) || (!ensureGACallDiff(induced,Gp,Gt,D))){ nbFail++; return printStats(false); } // Math all vertices with singleton domains int u; int nbToMatch = 0; int toMatch[Gp->nbVertices]; for (u=0; u<Gp->nbVertices; u++){ D->globalMatchingT[D->globalMatchingP[u]] = u; if (D->nbVal[u] == 1) toMatch[nbToMatch++] = u; } if (!matchVertices(nbToMatch,toMatch,induced,D,Gp,Gt)){ nbFail++; return printStats(false); } // Solve return printStats(!solve(timeLimit,firstSol, induced, verbose, D, Gp, Gt)); }
int path(struct graph* graphe, int sommet1, int sommet2){ tailAll(graphe); printf("Tail :\n"); printGraph(graphe); branchFrom(graphe, sommet1); printf("Branch from sommet %d :\n",graphe->sommet[sommet1].data); printGraph(graphe); if(graphe->sommet[sommet2].state == BRANCH){ return 1; } return 0; }
/*main------------------------------------------------------------------------*/ int main(int argc, char* argv[]) { //input validation if (argc != 2) { printf("Usage: %s output\n", argv[0]); exit(1); } //open file FILE *out; out = fopen(argv[1], "w"); //new graph Graph G = newGraph(10); Graph T; List S = newList(); int i; for (i = 1; i <= 9; i++) { addArc(G, i, i + 1); } addArc(G, 1, 2); //add graph and print out the adjacency fields for (i = 1; i <= getOrder(G); i++) { append(S, i); } fprintf(out, "\nThe adjacency list of G is:\n"); printGraph(out, G); //Run DFS and get the transpose DFS(G, S); T = transpose(G); fprintf(out, "\nTranspose of G is:\n"); printGraph(out, T); //print out fields fprintf(out, "Order of G is %d\n", getOrder(G)); fprintf(out, "Size of G is %d.\n", getSize(G)); fprintf(out, "Parent of 10 is %d.\n", getParent(G, 10)); fprintf(out, "Parent of 3 is %d.\n", getParent(G, 3)); fprintf(out, "Discover time of 1 is %d.\n", getDiscover(G, 1)); fprintf(out, "Finish time of 1 is %d.\n", getFinish(G, 1)); fprintf(out, "Discover time of 9 is %d.\n", getDiscover(G, 9)); fprintf(out, "Finish time of 9 is %d.\n", getFinish(G, 9)); //close file fclose(out); //exit return (0); }
int main(void) { if (trOrient()) printf("Графът е транзитивно неориентируем! \n"); else printGraph(); return 0; }
int main(int argc, char **argv) { srand(time(NULL)); if (argc < 2) { printf("Mandatory parameter is missing. 0 - Generate Kruskal testcase; 1 - Generate Trading Salesman testcase.\n"); } else if (atoi(argv[1]) == 0) { if (argc != 7) printf("Usage: 0 nbNodes nbEdges minWeight maxWeight outputName.\n"); else { graph graph = createGraph(atoi(argv[2]), atoi(argv[3]), atof(argv[4]), atof(argv[5])); printGraph(&graph, argv[6]); //printDot(&graph, 1); destroyGraph(&graph); } } else if (atoi(argv[1]) == 1) { if (argc != 4) printf("Usage: 1 nbNodes outputName.\n"); else { point *points = generatePoints(atoi(argv[2])); printGraphOfPoints(points, atoi(argv[2]), argv[3]); destroyPoints(points); } } else { printf("Illegal job id.\n"); return 0; } return 0; }
void dijkstra(graph* G, long initial_node, char debug) { long i,j,k; long aN; //actualNode G->D[initial_node] = 0; aN = initial_node; printf("Running dijkstra on graph\n"); if(debug) printGraph(G); for(i = 0; i < G->N; i++) { G->visited[aN] = VISITED; if(debug){ printf("It[%d] aN [%d]",i, aN); printStatus(G); printf("\n"); } //Find all nodes connected to aN for(j=0;j<G->N;j++){ if( (G->node[aN][j] != NO_CONN) ){ if( (G->D[aN] + G->node[aN][j]) < G->D[j] ){ G->D[j] = (G->D[aN] + G->node[aN][j]); } } } aN = getNextNode(G); } printf("Finished Dijkstra\n"); }
int main() { int V; scanf ("%d", &V); struct Graph* graph = createGraph(V); int i; for (i = 0; i < V; i++) { int vert, no_neghs; scanf("%d%d", &vert, &no_neghs); int j; for (j = 0; j < no_neghs; j++) { int neigh; scanf("%d", &neigh); addEdge(graph, vert, neigh); } } printGraph(graph); return 0; }
int main() { ALGraph *graph = malloc(sizeof(ALGraph)); createALGraph(graph); printGraph(graph); if(bellman_ford(graph, 0)>0) { printshortestPath(graph, 0); } else { printf("there is a negative circle\n"); } /* test = -1; if(test) { printf("true\n"); } else { printf("false\n"); } */ return 0; }
int main(int argc, char* argv[]){ int i, s, max, min, d, n=35; Graph G = NULL; // Build graph G G = newGraph(n); for(i=1; i<n; i++){ if( i%7!=0 ) addEdge(G, i, i+1); if( i<=28 ) addEdge(G, i, i+7); } addEdge(G, 9, 31); addEdge(G, 17, 13); addEdge(G, 14, 33); // Print adjacency list representation of G printGraph(stdout, G); // Properties of this graph printf("Number of vertices %d", getOrder(G)); printf("Number of edges: %d", getSize(G)); // Free objects freeGraph(&G); return(0); }
int main() { int V; int choice = 1; int src, dest; printf("\nHow many nodes you want to have in your graph\n"); scanf("%d",&V); GRAPH *graph = createGraph(V); printf("\nEnter an Edge like SRC DEST : ex- 0 1\n"); while(choice) { printf("\nENter Edge\n"); scanf("%d %d",&src,&dest); addEdge(graph, src, dest); printf("\nContinue?"); scanf("%d",&choice); } printGraph(graph); return 0; }
void main() { struct graph *graph = createGraph(); addVertex(graph, 1); addVertex(graph, 2); addVertex(graph, 3); addVertex(graph, 4); addVertex(graph, 5); addEdge(graph, 1, 2); addEdge(graph, 1, 3); addEdge(graph, 1, 4); addEdge(graph, 2, 1); addEdge(graph, 2, 3); addEdge(graph, 3, 2); addEdge(graph, 3, 1); addEdge(graph, 4, 1); addEdge(graph, 5, 2); addEdge(graph, 5, 3); addEdge(graph, 3, 5); addEdge(graph, 2, 5); printGraph(graph); bfsTraversal(graph); dfsTraversal(graph); }
int main(int argc, char const *argv[]) { int V; // The number of nodes printf("Enter the number of nodes : \n"); scanf("%d", &V); // Create a Graph G struct Graph* G; G = (struct Graph*)malloc(sizeof(struct Graph)); G->V = V; // Here the node at index i will have the value i. So, the zeroth index is left empty. G->arr = (struct listArray *)malloc((V+1)*sizeof(struct listArray)); for (int i=1; i<=V; i++) { G->arr[i].next = NULL; } printf("Enter pair of nodes to add Edge :\n"); printf("(Enter (0, 0) to terminate)\n"); int node1, node2; while(true) { scanf("%d %d", &node1, &node2); if (node1==0 || node2==0) {break;} else addEdge(G, node1, node2); addEdge(G, node2, node2); } printGraph(G); }
int main(){ ALGrapth G; int i, j; CreateGraph(&G); printGraph(G); printf("从顶点1开始深度优先遍历序列"); DFSTraverse(G, printVex); printf("\n"); printf("从顶点7开始深度优先遍历序列"); DFSTraverse(G, printVex, 6); printf("\n"); printf("从顶点1开始广度优先遍历序列"); BFSTraverse(G, printVex); printf("\n"); printf("从顶点7开始广度优先遍历序列"); BFSTraverse(G, printVex, 6); printf("\n"); printf("\n"); return 0; }
void bagOfThreads_bt(struct row* boolMatrix, struct row* warPath, int numEdges, int numProcess) { int i, j; // Memory ID sem_t *sem = calloc(1,sizeof(sem_t)); // Initializing semaphore sem_init(sem, 1, 0); // Initializes the shared memory and points to it // Copies over the original 2D array for(i = 0 ; i<numEdges; i++) for(j = 0; j < numEdges; j++) warPath[i].edgeNums[j] = boolMatrix[i].edgeNums[j]; //processWarshall(mem_ptr); //printf("Done with creation \n"); threadedWarshall_bt(warPath,numProcess,numEdges); printf("Final Graph\n"); printGraph(warPath,numEdges); printf("End\n"); // Free the shared memory //shmdt(mem_ptr); //shmctl(memory_id, IPC_RMID, NULL); //sem_destroy(sem); //munmap(sem, sizeof(sem_t)); return; }
int main(){ int V = 10; Graph *graph = createGraph(V); if(graph == NULL) return -1; geraGrafo(graph); printGraph(graph); /* addEdge(graph, 0, 1, 5); addEdge(graph, 0, 4, 2); addEdge(graph, 1, 2, 3); addEdge(graph, 1, 3, 8); addEdge(graph, 1, 4, 1); addEdge(graph, 2, 3, 2); addEdge(graph, 3, 4, 1); addEdge(graph, 4, 2, 4); */ listaHeap *cm = NULL; cm = (listaHeap*) dijkstra(graph, 0); int i; printf("%d:", cm->tam); for (i = 0; i < cm->tam; i++) { printf("id:%d, idNo:%d, peso:%d\n", i, cm[i].idNo, cm[i].peso); } printf("ok\n"); return 0; }
Graph kruskal(Graph& g) { Graph N; Equiv e(g.numEdges); qsort((void*) g.arrayEdges, g.numEdges, sizeof(Edge), (QSORT_COMPARE_TYPE) compareEdges); if(tracer==2) { printf("\nThe array of edges after sorting:\n"); printGraph(g); } for(int i = 0; i < g.numEdges; i++) { if(tracer==2) { printf("\nThe edges %i and %i are being considered.\n",g.arrayEdges[i].vertOne,g.arrayEdges[i].vertTwo); } if(!together(e, g.arrayEdges[i].vertOne, g.arrayEdges[i].vertTwo)) { if(tracer==2) { printf("The edges %i and %i were combined.\n",g.arrayEdges[i].vertOne,g.arrayEdges[i].vertTwo); } combine(e, g.arrayEdges[i].vertOne, g.arrayEdges[i].vertTwo); N.arrayEdges[N.numEdges++] = g.arrayEdges[i]; } else { if(tracer==2) { printf("The edges %i and %i were not combined.\n",g.arrayEdges[i].vertOne,g.arrayEdges[i].vertTwo); } } } return N; }
int main() { // create the graph FILE *f; int V; f=fopen("matrix.txt.","r"); fscanf(f,"%d",&V); int** adjMat=getMatrix(f,V); struct Graph* graph = createGraph(V); int i,j; printf(" The matrix is : \n\n"); printMatrix(adjMat,V); //for a un-oriented graph for(i=0;i<V;i++) for(j=i;j<V;j++) if(adjMat[i][j]==1) addEdge(graph, i,j); printGraph(graph);// print the adjacency list representation of the above graph //create adjacency graph from adjacency list printf("\n\n"); int** adjMatFromList=createAdjMatFromList(graph, V); printMatrix(adjMatFromList,V); return 0; }
int main() { int ver = 9; graph *g; g = initGraph(ver); addEdge(g, 0, 2); addEdge(g, 0, 3); addEdge(g, 1, 3); addEdge(g, 1, 4); addEdge(g, 2, 3); addEdge(g, 2, 5); addEdge(g, 2, 7); addEdge(g, 3, 4); addEdge(g, 4, 6); addEdge(g, 4, 8); addEdge(g, 5, 6); addEdge(g, 7, 8); printGraph(g); topoSort(g); }
GraphicPlot::GraphicPlot(QWidget *parent) : QMainWindow(parent), ui(new Ui::GraphicPlot) { ui->setupUi(this); qwtPlot = new QwtPlot(); ui->qwtLay->addWidget(qwtPlot); plot = new QwtPlotCurve("gr1"); // настройка функций // picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,qwtPlot->canvas()); picker = new QwtPlotPicker( QwtPlot::xBottom, QwtPlot::yLeft, // ассоциация с осями QwtPlotPicker::CrossRubberBand, // стиль перпендикулярных линий QwtPicker::ActiveOnly, // включение/выключение qwtPlot->canvas() ); // ассоциация с полем // Цвет перпендикулярных линий picker->setRubberBandPen( QColor( Qt::red ) ); // цвет координат положения указателя picker->setTrackerPen( QColor( Qt::black ) ); // непосредственное включение вышеописанных функций picker->setStateMachine( new QwtPickerDragPointMachine() ); connect(ui->actionSave_image,SIGNAL(triggered()),this,SLOT(printGraph())); connect(ui->actionSave_data,SIGNAL(triggered()),this,SLOT(saveDataSlot())); }
void QcepPlot::contextMenuEvent(QContextMenuEvent *event) { QMenu plotMenu(NULL, NULL); QAction *xLog = plotMenu.addAction("Log X Axis"); QAction *yLog = plotMenu.addAction("Log Y Axis"); QAction *auSc = plotMenu.addAction("Autoscale"); QAction *prGr = plotMenu.addAction("Print Graph..."); QcepPlotSettingsPtr set(m_PlotSettings); if (set) { xLog->setCheckable(true); yLog->setCheckable(true); xLog->setChecked(set->get_XAxisLog()); yLog->setChecked(set->get_YAxisLog()); QAction *action = plotMenu.exec(event->globalPos()); if (action == xLog) { set->toggle_XAxisLog(); } else if (action == yLog) { set->toggle_YAxisLog(); } else if (action == auSc) { autoScale(); } else if (action == prGr) { printGraph(); } } event->accept(); }
int main(void) { MGraph g; CreateGraph(&g); printGraph(&g); getchar(); }
void testConstructNFA1(){ regexps = malloc(sizeof(struct REentry)); regexps->regexp = "1*|a"; regexps->action = "printf;"; constructNFA(); printGraph(); destroyNFA(); }
int main() { graphInstance = createAdjMatrixGraph(); printGraph(graphInstance); return 0; }
int main(){ MGraph G; CreateGraph(&G); VertexType v; printGraph(G); MiniSpanTree_PRIM(G, '1'); return 0; }
int main(int argc, char * argv[]){ FILE *in, *out; if(argc!=3){ printf("Usage Error: FindPath [inputFile] [outputFile]\n"); exit(1); } in = fopen(argv[1], "r"); out = fopen(argv[2], "w"); if(in==NULL){ printf("Unable to read the input file\n"); exit(1); } if(out==NULL){ printf("Unable to write to output file\n"); exit(1); } int size; int source; int vertex; fscanf(in, "%d", &size); Graph G = newGraph(size); while(1){ fscanf(in, "%d %d", &source, &vertex);; if(source==0 && vertex==0) break; addEdge(G, source, vertex); } printGraph(out, G); fprintf(out, "\n"); while(1){ fscanf(in, "%d %d", &source, &vertex); if(source==0 && vertex==0) break; BFS(G, source); if(getDist(G, vertex)==INF){ fprintf(out, "The distance from %d to %d is infinity\nNo %d - %d path exists\n\n", source, vertex, source, vertex); continue; } List L = newList(); getPath(L, G, vertex); fprintf(out, "The distance from %d to %d is %d\nThe shortest %d - %d path is: ", source, vertex, getDist(G, vertex), source, vertex); printList(out, L); fprintf(out, "\n\n"); freeList(&L); } freeGraph(&G); fclose(in); fclose(out); }
int main() { int i, j; struct Graph* G; G = (struct Graph*)malloc(sizeof(struct Graph)); printf("Enter the number of nodes : \n"); scanf("%d", &G->V); // Allocate memory for Matrices G->adjMatrix = (int **)malloc((G->V + 1)*sizeof(int *)); G->costArray = (int *)malloc((G->V + 1)*sizeof(int)); G->parentArray = (int *)malloc((G->V + 1)*sizeof(int)); G->colorArray = (int *)malloc((G->V + 1)*sizeof(int)); for(i=0; i<=G->V+1; i++) { G->adjMatrix[i] = (int *)malloc((G->V + 1)*sizeof(int)); } // Initialize the Graph for (i=0; i<=G->V; i++) { for (j=0; j<=G->V; j++) { G->adjMatrix[i][j] = 0; } } // Add weight and edges printf("Enter the pair of nodes to add Edge and also the weight :\n"); printf("(Enter (0, 0, 0) to terminate)\n"); int node1, node2, weight; while(true) { scanf("%d %d %d", &node1, &node2, &weight); if (node1==0 || node2==0) {break;} else if (weight<=0) { printf("Weight must be positive!\n"); break; } else { G->adjMatrix[node1][node2] = weight; G->adjMatrix[node2][node1] = weight; } } // Run Dijkstra as all the nodes as starting nodes // Initialize Graph for (i=1; i<=G->V; ++i) { G->parentArray[i] = 0; G->costArray[i] = INFINITE; G->colorArray[i] = WHITE; } printf("Enter the node to start traversal from :\n"); int s; scanf("%d", &s); dijkstra(G, s); printGraph(G); }