struct Graph* makeGraph(){ struct Graph* g = (struct Graph*) malloc(sizeof(struct Graph)); scanf("%d",&g->V); scanf("%d",&g->E); int i =0, to=0, from=0, start=0; g->v_list = (struct Vertex**)malloc(sizeof(struct Vertex*)*(g->V+1)); for(i = 1;i<=g->V;i++){ g->v_list[i] = (struct Vertex*) malloc(sizeof(struct Vertex)); g->v_list[i]->v = i; g->v_list[i]->cost = 0; g->v_list[i]->visited = 0; } for( i =1;i<=g->E;i++){ scanf("%d", &from); scanf("%d",&to); if(from<=g->V && to<=g->V && from >=1 && to>=1){ struct Edge* e = makeEdge(g->v_list[from],g->v_list[to]); struct Edge* e2 = makeEdge(g->v_list[to],g->v_list[from]); /* add the edge to the adj_list */ /* in undirected graph, every vertex has its own edge */ g->v_list[from]->adj_list = add_edge(e,g->v_list[from]->adj_list); g->v_list[to]->adj_list = add_edge(e2,g->v_list[to]->adj_list); } } scanf("%d",&g->start); return g; }
// Recursive Delaunay Triangulation Procedure // Contains modifications for axis-switching division. void CDelaunay::build(int lo, int hi, EdgePointer *le, EdgePointer *re, int rows) { EdgePointer a, b, c, ldo, rdi, ldi, rdo, maxx, minx; int split, lowrows; int low, high; SitePointer s1, s2, s3; low = lo; high = hi; if ( low < (high-2) ) { // more than three elements; do recursion minx = sp[low]; maxx = sp[high]; if (rows == 1) { // time to switch axis of division spsorty( sp, low, high); rows = 65536; } lowrows = rows/2; split = low - 1 + (int) (0.5 + ((double)(high-low+1) * ((double)lowrows / (double)rows))); build( low, split, &ldo, &ldi, lowrows ); build( split+1, high, &rdi, &rdo, (rows-lowrows) ); doMerge(&ldo, ldi, rdi, &rdo); while (orig(ldo) != minx) { ldo = rprev(ldo); } while (orig(rdo) != maxx) { rdo = (SitePointer) lprev(rdo); } *le = ldo; *re = rdo; } else if (low >= (high - 1)) { // two or one points a = makeEdge(sp[low], sp[high]); *le = a; *re = (EdgePointer) sym(a); } else { // three points // 3 cases: triangles of 2 orientations, and 3 points on a line a = makeEdge((s1 = sp[low]), (s2 = sp[low+1])); b = makeEdge(s2, (s3 = sp[high])); splice((EdgePointer) sym(a), b); if (ccw(s1, s3, s2)) { c = connectLeft(b, a); *le = (EdgePointer) sym(c); *re = c; } else { *le = a; *re = (EdgePointer) sym(b); if (ccw(s1, s2, s3)) { // not colinear c = connectLeft(b, a); } } } }
/* *构造一个位置为point的新的顶点,并构造vertex指向新顶点的边 *@param[in] vertex 顶点 *@param[in] point 新生成的顶点位置 *@param[in] loop 当前环 *@return 新生成的半边 */ Half_Edge* EulerOperator::mev(Vertex* vertex,Point point,Loop* loop) { Vertex* vertex2 = new Vertex; vertex2->point = point; Edge* edge = makeEdge(vertex,vertex2); Half_Edge* he1 = edge->he1; Half_Edge* he2 = edge->he2; //将半边插入环中 he1->loop = loop; he2->loop = loop; if (loop->he==NULL) { loop->he = he1; he2->next = he1; he1->prev = he2; } else { Half_Edge* he = loop->he; while(he->next->ve1!=vertex) he = he->next; he2->next = he->next; he1->prev = he; he->next->prev = he2; he->next = he1; } insertEdge(loop->face->solid,edge); return he1; }
EdgePointer CDelaunay::connectRight(EdgePointer a, EdgePointer b) { EdgePointer ans; ans = makeEdge(dest(a), orig(b)); splice(ans, (EdgePointer) sym(a)); splice((EdgePointer) sym(ans), (EdgePointer) oprev(b)); return(ans); }
EdgePointer CDelaunay::connectLeft(EdgePointer a, EdgePointer b) { EdgePointer ans; ans = makeEdge(dest(a), orig(b)); splice(ans, (EdgePointer) lnext(a)); splice((EdgePointer) sym(ans), b); return(ans); }
Edge *Subdivision::connect(Edge *a, Edge *b) { Edge *e = makeEdge(); splice(e, a->Lnext()); splice(e->Sym(), b); e->EndPoints(a->Dest(), b->Org()); return e; }
QuadEdge *connect( QuadEdge *a, QuadEdge *b ) { QuadEdge *e = makeEdge(); e->setOrg( a->Dest() ); e->setDest( b->Org() ); splice( e, a->Lnext() ); splice( e->Sym(), b ); return e; }
void BMEsplitEdge(meTree *T, meNode *v, meEdge *e, double **A) { meEdge *newPendantEdge; meEdge *newInternalEdge; meNode *newNode; char nodeLabel[NODE_LABEL_LENGTH]; char edgeLabel1[EDGE_LABEL_LENGTH]; char edgeLabel2[EDGE_LABEL_LENGTH]; sprintf(nodeLabel,"I%d",T->size+1); sprintf(edgeLabel1,"E%d",T->size); sprintf(edgeLabel2,"E%d",T->size+1); /*make the new meNode and edges*/ newNode = makeNewNode(nodeLabel,T->size+1); newPendantEdge = makeEdge(edgeLabel1,newNode,v,0.0); newInternalEdge = makeEdge(edgeLabel2,newNode,e->head,0.0); /*update the matrix of average distances*/ BMEupdateAveragesMatrix(A,e,v,newNode); /*put them in the correct topology*/ newNode->parentEdge = e; e->head->parentEdge = newInternalEdge; v->parentEdge = newPendantEdge; e->head = newNode; T->size = T->size + 2; if (e->tail->leftEdge == e) /*actually this is totally arbitrary and probably unnecessary*/ { newNode->leftEdge = newInternalEdge; newNode->rightEdge = newPendantEdge; } else { newNode->leftEdge = newInternalEdge; newNode->rightEdge = newPendantEdge; } }
int main(int argc, char* argv[]){ welcomeScreen(); puts("\nLine:\tFrom:\t\t\tTo:\t\t\tTravel time:\n"); char* test = argv[1]; Edge new_edge = allocate(); makeEdge(test, new_edge); printf("%s\t%s\t%s\t%s\n", new_edge->bus_line, (new_edge)->travel_from->name, (new_edge)->travel_to->name, (new_edge)->travel_time); return 0; }
void CqParseTreeViz::visitChildren(T& node) { IqParseNode* child = static_cast<IqParseNode*>( node.GetInterface(ParseNode_Base))->pChild(); while(child != NULL) { makeEdge(node, *child); child->Accept(*this); child = child->pNextSibling(); } }
void CqParseTreeViz::Visit(IqParseNodeShader& node) { setNodeProperty(node, "label", boost::format( "{%s shader \\\"%s\\\" | {<args> args | <code> code } }") % node.strShaderType() % node.strName()); setNodeProperty(node, "fillcolor", functionColor); setNodeProperty(node, "shape", "record"); IqParseNode* code = static_cast<IqParseNode*>( node.GetInterface(ParseNode_Base))->pChild(); if(code) { IqParseNode* args = code->pNextSibling(); if(args) { makeEdge(node, *args, "args"); args->Accept(*this); } makeEdge(node, *code, "code"); code->Accept(*this); } }
void Subdivision::initMesh(const Vec2& A,const Vec2& B, const Vec2& C,const Vec2& D) { Vec2& a = A.clone(); Vec2& b = B.clone(); Vec2& c = C.clone(); Vec2& d = D.clone(); Edge *ea = makeEdge(); ea->EndPoints(a, b); Edge *eb = makeEdge(); splice(ea->Sym(), eb); eb->EndPoints(b, c); Edge *ec = makeEdge(); splice(eb->Sym(), ec); ec->EndPoints(c, d); Edge *ed = makeEdge(); splice(ec->Sym(), ed); ed->EndPoints(d, a); splice(ed->Sym(), ea); Edge *diag = makeEdge(); splice(ed->Sym(),diag); splice(eb->Sym(),diag->Sym()); diag->EndPoints(a,c); startingEdge = ea; first_face = NULL; makeFace(ea->Sym()).update(*this); makeFace(ec->Sym()).update(*this); }
void CqParseTreeViz::makeFunctionGraph(const IqFuncDef& funcDef) { // Only try to display graphs of user-defined functions. if(funcDef.fLocal()) { setNodeProperty(funcDef, "label", boost::format("{%s | {<args> args|<code> code}}") % funcDef.strName()); setNodeProperty(funcDef, "fillcolor", functionColor); setNodeProperty(funcDef, "shape", "record"); const IqParseNode* args = funcDef.pArgs(); if(args) { makeEdge(funcDef, *args, "args"); const_cast<IqParseNode*>(args)->Accept(*this); } const IqParseNode* code = funcDef.pDef(); if(code) { makeEdge(funcDef, *code, "code"); const_cast<IqParseNode*>(code)->Accept(*this); } } }
/* *构造顶点ve1到ve2的一条边,同时构造一个新面 *注意当前loop的走向变为ve1->ve2,新面loop的走向为ve2->ve1 *@param[in] ve1 顶点1 *@param[in] ve2 顶点2 *@param[in] loop 当前环 *@return 新生成的面 */ Face* EulerOperator::mef(Vertex* ve1,Vertex* ve2,Loop* loop) { Edge* edge = makeEdge(ve1,ve2); Half_Edge* he1 = edge->he1; Half_Edge* he2 = edge->he2; //创建新环 Loop* loop2 = new Loop; Half_Edge *tmpHe1,*tmpHe2; Half_Edge* he = loop->he; while(he->ve1!=ve1) he=he->next; tmpHe1 = he; while(he->ve1!=ve2) he=he->next; tmpHe2 = he; tmpHe1->prev->next = he1; he1->prev = tmpHe1->prev; he2->next = tmpHe1; tmpHe1->prev = he2; tmpHe2->prev->next = he2; he2->prev = tmpHe2->prev; he1->next = tmpHe2; tmpHe2->prev = he1; loop->he = he1; he1->loop = loop; loop2->he = he2; he2->loop = loop2; //创建新面 Face* face = new Face; Solid* solid = loop->face->solid; insertEdge(solid,edge); insertFace(solid,face); insertLoop(face,loop2); return face; }
graph* makeGraph(int v , int e){ graph *temp = new graph; int i , j , k,sour , dest,wei,p; vertex *t; temp->noofedges = e; temp->noofvertex = v; temp->v = new vertex*[v]; temp->e = new edge*[e]; for(i = 0 ; i < v ; i ++){ t = makeVertex(i); if(t == NULL){ cout<<"Error Occured"; } temp->v[i] = t; } cout<<"Enter 0 if weighted otherwise 1"<<endl; cin>>j; cout<<"Enter 0 if directed otherwise 1"<<endl; cin>>p; cout<<"Enter the source and destination of edges (between 0 and no. of the edge - 1):- "<<endl; for(i = 0 ; i < e; i++){ cin>>sour>>dest; if(j) wei = 0; else cin>>wei; k = insertAdj(temp->v[sour] , temp->v[dest] , wei); if(p) k = insertAdj(temp->v[dest] , temp->v[sour] , wei); if(k) cout<<"Error in making adjacentylist "; temp->e[i] = makeEdge(temp->v[sour] , temp->v[dest] , wei); } return temp; }
void addEdge(int u, int v, int w) { Edge *e1 = makeEdge(u, v, w), *e2 = makeEdge(v, u, 0); e1->inv = e2, e2->inv = e1; }
void addEdge(int u, int v, int c) { edge_t *e1 = makeEdge(u, v, c), *e2 = makeEdge(v, u, 0); e1->inverse = e2, e2->inverse = e1; }/*}}}*/
void addEdge(int u, int v, int id) { Edge *e1 = makeEdge(u, v, id), *e2 = makeEdge(v, u, id); e1->inv = e2, e2->inv = e1; }
void Solve::addEdge(int u, int v, Flow_t cap) { Edge *e1 = makeEdge(u, v, cap), *e2 = makeEdge(v, u, 0); e1->inverse = e2, e2->inverse = e1; }
void addEdge(int u, int v, int w) { Edge *e1 = makeEdge(u, v, w), *e2 = makeEdge(v, u, w); e1->inv = e2, e2->inv = e1; e2->isRev = true; }
void Solve::addEdge(int u, int v) { Edge *e1 = makeEdge(u, v), *e2 = makeEdge(v, u); e1->inverse = e2, e2->inverse = e1; }
Edge *Subdivision::spoke(Vec2& x, Edge *e) { Triangle *new_faces[4]; int facedex = 0; // // NOTE: e is the edge returned by locate(x) // if ( (x == e->Org()) || (x == e->Dest()) ) { // point is already in the mesh // #ifdef _INC_IOSTREAM std::cerr << "WARNING: Tried to reinsert point: " << x << std::endl; std::cerr << " org: " << e->Org() << std::endl; std::cerr << " dest: " << e->Dest() << std::endl; #endif return NULL; } Edge *boundary_edge = NULL; Triangle *lface = e->Lface(); lface->dontAnchor(e); new_faces[facedex++] = lface; if( onEdge(x,e) ) { if( ccwBoundary(e) ) { // // e lies on the boundary // Defer deletion until after new edges are added. boundary_edge = e; } else { Triangle *sym_lface = e->Sym()->Lface(); new_faces[facedex++] = sym_lface; sym_lface->dontAnchor(e->Sym()); e = e->Oprev(); deleteEdge(e->Onext()); } } else { // x lies within the Lface of e } Edge *base = makeEdge(e->Org(), x.clone()); splice(base, e); startingEdge = base; do { base = connect(e, base->Sym()); e = base->Oprev(); } while( e->Lnext() != startingEdge ); if( boundary_edge ) deleteEdge(boundary_edge); // Update all the faces in our new spoked polygon. // If point x on perimeter, then don't add an exterior face base = boundary_edge ? startingEdge->Rprev() : startingEdge->Sym(); do { if( facedex ) new_faces[--facedex]->reshape(base); else makeFace(base); base = base->Onext(); } while( base != startingEdge->Sym() ); return startingEdge; }
/********************************************** MAIN FUNCTION *************************************************/ int main() { int v, i, j, index1, index2, integers1[1000] = {0}, integers2[1000] = {0}, number1, number2; char start[100], key[100], s[100]; scanf("%s", s); v = checkFloat(s); getchar(); if(v < 0 || v > 1000 || v == -1) { printf("INVALID INPUT\n"); return 0; } struct Graph *graph = makeGraph(v); for(i = 0; i < 10000; i++) { visited[i] = 0; } char input[1000][1000], weight[1000][1000]; for(i = 0; i < v; i++) { scanf("%[^\n]s", input[i]); getchar(); } for(i = 0; i < v; i++) { scanf("%[^\n]s", weight[i]); getchar(); } for(i = 0; i < v; i++) { index1 = convertInput(input[i], integers1); index2 = convertInput(weight[i], integers2); if(index1 == -1 || index2 == -1) { printf("INVALID INPUT\n"); return 0; } for(j = 0; j < index2; j++) { if(integers2[j] < 0 || integers2[j] > 10000) { printf("INVALID INPUT\n"); return 0; } } if(index1 > 0) { if(isSorted(integers1, index1) == 0) { printf("INVALID INPUT\n"); return 0; } } for(j = 0; j < index1; j++) { if(integers1[j] < 0 || integers1[j] > (v - 1)) { printf("INVALID INPUT\n"); return 0; } makeEdge(graph, i, integers1[j], integers2[j]); } } while(1) { char choice[5]; scanf("%s", choice); if(strcmp(choice, "apsp") == 0) { scanf("%s", start); number1 = checkFloat(start); if(number1 < 0 || number1 > (v - 1)) { printf("INVALID INPUT\n"); return 0; } dijkstra(graph, number1); for(i = 0; i < graph->v; i++) { if(min_dist_array[i] != 50000) { printf("%d ", min_dist_array[i]); } else { printf("INF "); } } printf("\n"); } else if(strcmp(choice, "sssp") == 0) { scanf("%s %s", start, key); number1 = checkFloat(start); if(number1 < 0 || number1 > (v - 1)) { printf("INVALID INPUT\n"); return 0; } number2 = checkFloat(key); if(number2 < 0 || number2 > (v - 1)) { printf("INVALID INPUT\n"); return 0; } dijkstra(graph, number1); if(min_dist_array[number2] != 50000) { printf("%d", min_dist_array[number2]); } else { printf("UNREACHABLE"); } printf("\n"); } else if(strcmp(choice, "stop") == 0) { break; } else { printf("ENTER CORRECT CHOICE\n"); } } }
int main(void) { while(scanf("%hd %d", &verts, &edges) != -1) { for(short int v = 0; v < verts; ++ v) { tree[v].clear(); repr[v] = v; for(short int v2 = 0; v2 < verts; ++ v2) longest[v][v2] = -1; } for(int c = 0; c <= max; ++ c) sort[c].clear(); max = 0; for(int e = 0; e < edges; ++ e) { scanf("%hd %hd %d", &start, &end, &cost); sort[cost].push_back(makeEdge(start - 1, end - 1)); max = std::max(max, cost); } result = 0; best = 0; count = 0; for(int c = 0; c <= max && count < verts - 1; ++ c) for(unsigned int e = 0; e < sort[c].size(); ++ e) { int &act = sort[c][e]; if(unionUnion(edgeFirst(act), edgeSecond(act))) { tree[edgeFirst(act)].push_back(makeCostEdge(c, edgeSecond(act))); tree[edgeSecond(act)].push_back(makeCostEdge(c, edgeFirst(act))); ++ count; result += c; } } if(count != verts - 1) { puts("disconnected"); continue; } for(int v = 0; v < verts; ++ v) findLongest(v, v); for(int c = 0; c <= max; ++ c) for(unsigned int e = 0; e < sort[c].size(); ++ e) { int &act = sort[c][e]; tmp = c + longest[edgeFirst(act)][edgeSecond(act)]; if(tmp > best) best = tmp; } printf("%d\n", result - best); } return 0; }
meTree *BMEaddSpecies(meTree *T,meNode *v, double **D, double **A) /*the key function of the program addSpeices inserts the meNode v to the meTree T. It uses testEdge to see what the relative weight would be if v split a particular edge. Once insertion point is found, v is added to T, and A is updated. Edge weights are not assigned until entire meTree is build*/ { meTree *T_e; meEdge *e; /*loop variable*/ meEdge *e_min; /*points to best meEdge seen thus far*/ double w_min = 0.0; /*used to keep track of meTree weights*/ /*initialize variables as necessary*/ /*CASE 1: T is empty, v is the first node*/ if (NULL == T) /*create a meTree with v as only vertex, no edges*/ { T_e = newTree(); T_e->root = v; /*note that we are rooting T arbitrarily at a leaf. T->root is not the phylogenetic root*/ v->index = 0; T_e->size = 1; return(T_e); } /*CASE 2: T is a single-vertex tree*/ if (1 == T->size) { v->index = 1; e = makeEdge("",T->root,v,0.0); sprintf(e->label,"E1"); A[v->index][v->index] = D[v->index2][T->root->index2]; T->root->leftEdge = v->parentEdge = e; T->size = 2; return(T); } /*CASE 3: T has at least two nodes and an edge. Insert new node by breaking one of the edges*/ v->index = T->size; BMEcalcNewvAverages(T,v,D,A); /*calcNewvAverages will update A for the row and column include the meNode v. Will do so using pre-existing averages in T and information from A,D*/ e_min = T->root->leftEdge; e = e_min->head->leftEdge; while (NULL != e) { BMEtestEdge(e,v,A); /*testEdge tests weight of meTree if loop variable e is the meEdge split, places this value in the e->totalweight field */ if (e->totalweight < w_min) { e_min = e; w_min = e->totalweight; } e = topFirstTraverse(T,e); } /*e_min now points at the meEdge we want to split*/ if (verbose) printf("Inserting %s between %s and %s on %s\n",v->label,e_min->tail->label, e_min->head->label,e_min->label); BMEsplitEdge(T,v,e_min,A); return(T); }
node *decodeNewickSubtree(char *treeString, tree *T, int *uCount) { node *thisNode; node *centerNode; double thisWeight; edge *thisEdge; // char label[MAX_LABEL_LENGTH]; char stringWeight[MAX_LABEL_LENGTH]; int state; int i = 0; int j; int left,right; int parcount; // snprintf(label,14,"Default_Label\0"); left = right = 0; parcount = 0; state = ReadOpenParenthesis; if('(' == treeString[0]) parcount++; //centerNode = makeNode(label,NULL,nodeCount++); centerNode = makeNode("",NULL,nodeCount++); T->size++; while(parcount > 0) { while(whiteSpace(treeString[i])) i++; switch(state) { case(ReadOpenParenthesis): if('(' != treeString[0]) { Rprintf("Error reading subtree.\n"); exit(0); } i++; state = ReadSubTree; break; case(ReadSubTree): if('(' == treeString[i]) /*if treeString[i] is a left parenthesis, we scan down the string until we find its partner. the relative number of '('s vs. ')'s is counted by the variable parcount*/ { left = i++; parcount++; while(parcount > 1) { while (('(' != treeString[i]) && (')' != treeString[i])) i++; /*skip over characters which are not parentheses*/ if('(' == treeString[i]) parcount++; else if (')' == treeString[i]) parcount--; i++; } /*end while */ right = i; /*at this point, the subtree string goes from treeString[left] to treeString[right - 1]*/ thisNode = decodeNewickSubtree(treeString + left,T,uCount); /*note that this step will put thisNode in T*/ i = right; /*having created the node for the subtree, we move to assigning the label for the new node. treeString[right] will be the start of this label */ } /* end if ('(' == treeString[i]) condition */ else { //thisNode = makeNode(label,NULL,nodeCount++); thisNode = makeNode("",NULL,nodeCount++); T->size++; } state = ReadLabel; break; case(ReadLabel): left = i; /*recall "left" is the left marker for the substring, "right" the right*/ if (':' == treeString[i]) /*this means an internal node?*/ { //sprintf(thisNode->label,"I%d",(*uCount)++); //snprintf(thisNode->label,MAX_LABEL_LENGTH,"I%d",(*uCount)++); (*uCount)++; right = i; } else { while((':' != treeString[i]) && (',' != treeString[i]) && (')' != treeString[i])) i++; right = i; j = 0; for(i = left; i < right;i++) if(!(whiteSpace(treeString[i]))) thisNode->label[j++] = treeString[i]; thisNode->label[j] = '\0'; } if(':' == treeString[right]) state = ReadWeight; else { state = AddEdge; thisWeight = 0.0; } i = right + 1; break; case(ReadWeight): left = i; while ((',' != treeString[i]) && (')' != treeString[i])) i++; right = i; j = 0; for(i = left; i < right; i++) stringWeight[j++] = treeString[i]; stringWeight[j] = '\0'; thisWeight = atof(stringWeight); state=AddEdge; break; case(AddEdge): //thisEdge = makeEdge(label,centerNode,thisNode,thisWeight); thisEdge = makeEdge("",centerNode,thisNode,thisWeight); thisNode->parentEdge = thisEdge; if (NULL == centerNode->leftEdge) centerNode->leftEdge = thisEdge; else if (NULL == centerNode->rightEdge) centerNode->rightEdge = thisEdge; else if (NULL == centerNode->middleEdge) centerNode->middleEdge = thisEdge; else { Rprintf("Error: node %s has too many (>3) children.\n",centerNode->label); exit(0); } //sprintf(thisEdge->label,"E%d",edgeCount++); //snprintf(thisEdge->label,MAX_LABEL_LENGTH,"E%d",edgeCount++); edgeCount++; i = right + 1; if (',' == treeString[right]) state = ReadSubTree; else parcount--; break; } } return(centerNode); }