void dijkstra(Graph G, Vertex s, Vertex parnt[], double cst[]) {
Vertex v, w;
link p;
GRAPHmaxcst(G);
for (v = 0; v < G->V; v++) {
cst[v] = INFINITO;
parnt[v] = -1;
}
PQinit(G->V);
cst[s] = 1;
parnt[s] = s;
PQinsert(s);
while (!PQempty()) {
v = PQdelmax(cst);
for(p=G->adj[v];p!=NULL;p=p->next) {
if (cst[w=p->w]==INFINITO) {
cst[w]=cst[v]*p->cst;
parnt[w]=v;
PQinsert(w);
}
else if(cst[w]<cst[v]*p->cst) {
cst[w]=cst[v]*p->cst;
parnt[w] = v;
}
}
}
PQfree();
}
void dijkstra(Digraph G, Vertex s){
Vertex v, w; link p;
for (v = 0; v < G->V; v++) {
cst[v] = INFINITO;
parnt[v] = -1;
}
PQinit(G->V);
cst[s] = 0;
parnt[s] = s;
PQinsert(s);
while (!PQempty()) {
v = PQdelmin();
for(p=G->adj[v];p!=NULL;p=p->next)
if(cst[w=p->w]==INFINITO){
cst[w]=cst[v]+p->cst;
parnt[w]=v;
PQinsert(w);
}else if(cst[w]>cst[v]+p->cst){
cst[w]=cst[v]+p->cst;
parnt[w] = v;
PQdec(w);
}
}
PQfree();
}
/* makeMultiSpline:
* FIX: we don't really use the shortest path provided by ED_path,
* so avoid in neato spline code.
* Return 0 on success.
*/
int makeMultiSpline(graph_t* g, edge_t* e, router_t * rtr, int doPolyline)
{
Ppolyline_t line = ED_path(e);
node_t *t = agtail(e);
node_t *h = aghead(e);
pointf t_p = line.ps[0];
pointf h_p = line.ps[line.pn - 1];
tripoly_t *poly;
int idx;
int *sp;
int t_id = rtr->tn;
int h_id = rtr->tn + 1;
int ecnt = rtr->tg->nedges;
PPQ pq;
PQTYPE *idxs;
PQVTYPE *vals;
int ret;
/* Add endpoints to triangle graph */
addEndpoint(rtr, t_p, t, t_id, ED_tail_port(e).side);
addEndpoint(rtr, h_p, h, h_id, ED_head_port(e).side);
/* Initialize priority queue */
PQgen(&pq.pq, rtr->tn + 2, -1);
idxs = N_GNEW(pq.pq.PQsize + 1, PQTYPE);
vals = N_GNEW(pq.pq.PQsize + 1, PQVTYPE);
vals[0] = 0;
pq.vals = vals + 1;
pq.idxs = idxs + 1;
/* Find shortest path of triangles */
sp = triPath(rtr->tg, rtr->tn+2, h_id, t_id, (PQ *) & pq);
free(vals);
free(idxs);
PQfree(&(pq.pq), 0);
/* Use path of triangles to generate guiding polygon */
poly = mkPoly(rtr, sp, h_id, t_id, h_p, t_p, &idx);
free(sp);
/* Generate multiple splines using polygon */
ret = genroute(g, poly, 0, idx, e, doPolyline);
freeTripoly (poly);
resetGraph(rtr->tg, rtr->tn, ecnt);
return ret;
}
/* orthoEdges:
* For edges without position information, construct an orthogonal routing.
* If doLbls is true, use edge label info when available to guide routing,
* and set label pos for those edges for which this info is not available.
*/
void
orthoEdges (Agraph_t* g, int doLbls)
{
sgraph* sg;
maze* mp;
int n_edges;
route* route_list;
int i, gstart;
Agnode_t* n;
Agedge_t* e;
snode* sn;
snode* dn;
epair_t* es = N_GNEW(agnedges(g), epair_t);
cell* start;
cell* dest;
PointSet* ps;
textlabel_t* lbl;
if (Concentrate)
ps = newPS();
#ifdef DEBUG
{
char* s = agget(g, "odb");
char c;
odb_flags = 0;
if (s && (*s != '\0')) {
while ((c = *s++)) {
switch (c) {
case 'c' :
odb_flags |= ODB_CHANG; // emit channel graph
break;
case 'i' :
odb_flags |= (ODB_SGRAPH|ODB_IGRAPH); // emit search graphs
break;
case 'm' :
odb_flags |= ODB_MAZE; // emit maze
break;
case 'r' :
odb_flags |= ODB_ROUTE; // emit routes in maze
break;
case 's' :
odb_flags |= ODB_SGRAPH; // emit search graph
break;
}
}
}
}
#endif
if (doLbls) {
agerr(AGWARN, "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n");
doLbls = 0;
}
mp = mkMaze (g, doLbls);
sg = mp->sg;
#ifdef DEBUG
if (odb_flags & ODB_SGRAPH) emitSearchGraph (stderr, sg);
#endif
/* store edges to be routed in es, along with their lengths */
n_edges = 0;
for (n = agfstnode (g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g,e)) {
if ((Nop == 2) && ED_spl(e)) continue;
if (Concentrate) {
int ti = AGID(agtail(e));
int hi = AGID(aghead(e));
if (ti <= hi) {
if (isInPS (ps,ti,hi)) continue;
else addPS (ps,ti,hi);
}
else {
if (isInPS (ps,hi,ti)) continue;
else addPS (ps,hi,ti);
}
}
es[n_edges].e = e;
es[n_edges].d = edgeLen (e);
n_edges++;
}
}
route_list = N_NEW (n_edges, route);
qsort((char *)es, n_edges, sizeof(epair_t), (qsort_cmpf) edgecmp);
gstart = sg->nnodes;
PQgen (sg->nnodes+2);
sn = &sg->nodes[gstart];
dn = &sg->nodes[gstart+1];
for (i = 0; i < n_edges; i++) {
#ifdef DEBUG
if ((i > 0) && (odb_flags & ODB_IGRAPH)) emitSearchGraph (stderr, sg);
#endif
e = es[i].e;
start = CELL(agtail(e));
dest = CELL(aghead(e));
if (doLbls && (lbl = ED_label(e)) && lbl->set) {
}
else {
if (start == dest)
addLoop (sg, start, dn, sn);
else {
addNodeEdges (sg, dest, dn);
addNodeEdges (sg, start, sn);
}
if (shortPath (sg, dn, sn)) goto orthofinish;
}
route_list[i] = convertSPtoRoute(sg, sn, dn);
reset (sg);
}
PQfree ();
mp->hchans = extractHChans (mp);
mp->vchans = extractVChans (mp);
assignSegs (n_edges, route_list, mp);
if (setjmp(jbuf))
goto orthofinish;
assignTracks (n_edges, route_list, mp);
#ifdef DEBUG
if (odb_flags & ODB_ROUTE) emitGraph (stderr, mp, n_edges, route_list, es);
#endif
attachOrthoEdges (g, mp, n_edges, route_list, &sinfo, es, doLbls);
orthofinish:
if (Concentrate)
freePS (ps);
for (i=0; i < n_edges; i++)
free (route_list[i].segs);
free (route_list);
freeMaze (mp);
}
