void dijkstra(node& p)
{
if ( !ok(p) || stop || isvisited(p) )
return;
// neighbors
node a(p.x+1, p.y);
node b(p.x, p.y+1);
// tentative distances
uint32_t d = getdist(p);
uint32_t da = sum(d, getcost(a));
uint32_t db = sum(d, getcost(b));
// update distances
if ( !isvisited(a) && da < getdist(a) ) setdist(a, da);
if ( !isvisited(b) && db < getdist(b) ) setdist(b, db);
// mark this node
setvisited(p);
// has dest node been visited?
if ( isvisited(node(xmax-1, ymax-1)) ) {
// ...
uint32_t final = getdist(node(xmax-1, ymax-1));
printf("Finished with distance %u\n", final);
stop = true;
return;
}
/* get qgram-distance from tree and set all qgram-freqencies
* to 0 (so the tree can be reused).
*/
static void getdist(qtree *Q, double *d){
if (Q == NULL) return;
d[0] += (double) abs(Q->n[0] - Q->n[1]);
Q->n[0] = 0;
Q->n[1] = 0;
getdist(Q->left, d);
getdist(Q->right,d);
}
static int cmpf(Dt_t * d, void *key1, void *key2, Dtdisc_t * disc)
{
double t;
t = getdist((Agnode_t *) key1) - getdist((Agnode_t *) key2);
if (t < 0)
return -1;
if (t > 0)
return 1;
if (key1 < key2)
return -1;
if (key1 > key2)
return 1;
return 0;
}
static void update(Dict_t * Q, Agnode_t * dest, Agnode_t * src, double len)
{
double newlen = getdist(src) + len;
double oldlen = getdist(dest);
if (oldlen == 0) { /* first time to see dest */
setdist(dest, newlen);
dtinsert(Q, dest);
} else if (newlen < oldlen) {
dtdelete(Q, dest);
setdist(dest, newlen);
dtinsert(Q, dest);
}
}
int main (void){
int** dist;
char ch[10];
dist= get (); //得到文件数据
printf("请输入起点城市：");
scanf("%s",ch);
getdist(ch,dist); //得到遍历数据
return 0;
}
void dijkstra(node& p)
{
if ( !ok(p) || stop || isvisited(p) )
return;
// neighbors
node a(p.x+1, p.y); // move right
node b(p.x, p.y+1); // move down
node c(p.x, p.y-1); // move up
node D(p.x-1, p.y); // move left
// tentative distances
uint32_t d = getdist(p);
uint32_t da = sum(d, getcost(a));
uint32_t db = sum(d, getcost(b));
uint32_t dc = sum(d, getcost(c));
uint32_t dd = sum(d, getcost(D));
// update distances
if ( !isvisited(a) && da < getdist(a) ) setdist(a, da);
if ( !isvisited(b) && db < getdist(b) ) setdist(b, db);
if ( !isvisited(c) && dc < getdist(c) ) setdist(c, dc);
if ( !isvisited(D) && dd < getdist(D) ) setdist(D, dd);
// mark this node
setvisited(p);
// has all dest nodes been visited?
if ( allvisited() ) {
// target node is lower right
final = getdist(node(xmax-1, ymax-1));
stop = true;
return;
}
static void post(Agraph_t * g)
{
Agnode_t *v;
Agnode_t *prev;
char buf[256];
char dflt[256];
Agsym_t *sym;
Agsym_t *psym;
double dist, oldmax;
double maxdist = 0.0; /* maximum "finite" distance */
sym = agattr(g, AGNODE, "dist", "");
if (doPath)
psym = agattr(g, AGNODE, "prev", "");
if (setall)
sprintf(dflt, "%.3lf", HUGE);
for (v = agfstnode(g); v; v = agnxtnode(g, v)) {
dist = getdist(v);
if (dist) {
dist--;
sprintf(buf, "%.3lf", dist);
agxset(v, sym, buf);
if (doPath && (prev = getprev(v)))
agxset(v, psym, agnameof(prev));
if (maxdist < dist)
maxdist = dist;
} else if (setall)
agxset(v, sym, dflt);
}
sym = agattrsym(g, "maxdist");
if (sym) {
if (!setall) {
/* if we are preserving distances in other components,
* check previous value of maxdist.
*/
oldmax = atof(agxget(g, sym));
if (oldmax > maxdist)
maxdist = oldmax;
}
sprintf(buf, "%.3lf", maxdist);
agxset(g, sym, buf);
} else {
sprintf(buf, "%.3lf", maxdist);
agattr(g, AGRAPH, "maxdist", buf);
}
agclean(g, AGNODE, "dijkstra");
agclean(g, AGEDGE, "dijkstra");
}
/*Get qgram distances
* Input
* s: a string
* t: a string
* x: length of s
* y: length of t
* q: the 'q' in q-gram
* Q: a qtree
* int: distance distance function to compute:
* 0 : q-gram distance
* 1 : cosine distance
* 2 : jaccard distance
*
*
* Return values:
* >=0 : qgram distance
* -1 : infinite distance
* -2 : Not enough memory
*/
static double qgram_tree(
unsigned int *s,
unsigned int *t,
unsigned int x,
unsigned int y,
unsigned int q,
qtree *Q,
int distance
){
// return -1 when q is larger than the length of the shortest string.
if ( q > (x <= y ? x : y) ) return -1.0;
// rare edge cases.
if ( q == 0 ){
if ( x + y > 0 ){ // distance undefined
return -1.0;
} else { // x == y == 0.
return 0.0;
}
}
double dist[3] = {0,0,0};
Q = push_string(s, x, q, Q, 0, 2);
if (Q == NULL) return -2.0;
Q = push_string(t, y, q, Q, 1, 2);
if (Q == NULL) return -2.0;
switch ( distance ){
case 0:
getdist(Q,dist);
break;
case 1:
getcosine(Q, dist);
if (dist[0]==dist[1] && dist[0]==dist[2]){
// strings are equal. Prevent machine rounding about 0.0
dist[0] = 0.0;
} else {
// there are several ways to express the rhs (including ones that give 0L
// at equal strings) but this has least chance of overflow.
dist[0] = 1.0 - dist[0]/(sqrt(dist[1]) * sqrt(dist[2]));
}
break;
case 2:
getjaccard(Q,dist);
dist[0] = 1.0 - dist[0]/dist[1];
break;
default:
break;
}
return dist[0];
}
/*Get qgram distances
* Input
* s: a string
* t: a string
* x: length of s
* y: length of t
* q: the 'q' in q-gram
* Q: a qtree
* int: distance distance function to compute:
* 0 : q-gram distance
* 1 : cosine distance
* 2 : jaccard distance
*
*
* Return values:
* >=0 : qgram distance
* -1 : infinite distance
* -2 : Not enough memory
*/
double qgram_dist(
unsigned int *s,
int x,
unsigned int *t,
int y,
unsigned int q,
qtree **Qp,
int distance
){
// rare edge case: q==0. Note that we return 0 for all cases where
// q equals zero. In the R journal paper we used Inf for cases where
// q=0 and |s| or |t| > 0
if ( q == 0 ) return 0.0;
double dist[3] = {0,0,0};
*Qp = push_string(s, x, q, *Qp, 0, 2);
*Qp = push_string(t, y, q, *Qp, 1, 2);
if (*Qp == NULL) return 0;
qtree *Q = *Qp;
switch ( distance ){
case 0:
getdist(Q,dist);
break;
case 1:
getcosine(Q, dist);
if (dist[0]==dist[1] && dist[0]==dist[2]){
// strings are equal. Prevent machine rounding about 0.0
dist[0] = 0.0;
} else {
// there are several ways to express the rhs (including ones that give 0L
// at equal strings) but this has least chance of overflow
// fabs is taken to avoid numerical -0.
dist[0] = fabs(1.0 - dist[0]/(sqrt(dist[1]) * sqrt(dist[2])));
}
break;
case 2:
getjaccard(*Qp,dist);
dist[0] = 1.0 - dist[0]/dist[1];
break;
default:
break;
}
return dist[0];
}
static void getdistl(
double *d,
unsigned int nstart,
double stime[],
double sstart[],
double send[],
double cost
)
{
double *tli, *tlj;
double dist;
unsigned int i,j,itli,itlj;
unsigned int nspi,nspj;
double junk;
for (i=0; i<nstart; i++) {
nspi=(int)(send[i]-sstart[i]+1);
if (nspi>0) {
tli=dvector(0,nspi-1);
for (itli=0; itli<nspi; itli++) {
tli[itli]=stime[itli+(int)sstart[i]-1];
/*printf("\n%d %f",itli,tli[itli]);*/
}
}
for (j=i+1; j<nstart; j++) {
nspj=(int)(send[j]-sstart[j]+1);
/*printf("\nnspi=%d\tnspj=%d",nspi,nspj);*/
if (nspi>0 && nspj>0) {
tlj=dvector(0,nspj-1);
for (itlj=0; itlj<nspj; itlj++) {
tlj[itlj]=stime[itlj+(int)sstart[j]-1];
/*printf("\n%d %f",itlj,tlj[itlj]);*/
}
getdist(&dist,nspi,tli,nspj,tlj,cost);
/*printf("\t%f",dist);*/
free_dvector(tlj,0,nspj-1);
}
if (nspi==0 && nspj>0) dist=nspj;
else if (nspj==0 && nspi>0) dist=nspi;
else if (nspj==0 && nspi==0) dist=0;
/*printf("\n%d %d %d %f",i,j,i*nstart+j,dist);*/
d[i*nstart+j]=d[j*nstart+i]=dist;
}
if (nspi>0) free_dvector(tli,0,nspi-1);
}
return;
}
/*Get qgram distances
* Input
* s: a string
* t: a string
* x: length of s
* y: length of t
* q: the 'q' in q-gram
* Q: a qtree
* int: distance distance function to compute:
* 0 : q-gram distance
* 1 : cosine distance
* 2 : jaccard distance
*
*
* Return values:
* >=0 : qgram distance
* -1 : infinite distance
* -2 : Not enough memory
*/
double qgram_dist(
unsigned int *s,
int x,
unsigned int *t,
int y,
unsigned int q,
qtree *Q,
int distance
){
// return -1 when q is larger than the length of the shortest string.
if ( q > (x <= y ? x : y) ) return -1.0;
// rare edge case: q==0. Note that we return 0 for all cases where
// q equals zero. In the R journal paper we used Inf for cases where
// q=0 and |s| or |t| > 0
if ( q == 0 ) return 0.0;
double dist[3] = {0,0,0};
Q = push_string(s, x, q, Q, 0, 2);
if (Q == NULL) return -2.0;
Q = push_string(t, y, q, Q, 1, 2);
if (Q == NULL) return -2.0;
switch ( distance ){
case 0:
getdist(Q,dist);
break;
case 1:
getcosine(Q, dist);
if (dist[0]==dist[1] && dist[0]==dist[2]){
// strings are equal. Prevent machine rounding about 0.0
dist[0] = 0.0;
} else {
// there are several ways to express the rhs (including ones that give 0L
// at equal strings) but this has least chance of overflow.
dist[0] = 1.0 - dist[0]/(sqrt(dist[1]) * sqrt(dist[2]));
}
break;
case 2:
getjaccard(Q,dist);
dist[0] = 1.0 - dist[0]/dist[1];
break;
default:
break;
}
return dist[0];
}
// Return unvisited node with smallest tentative distance
static node nextnode()
{
node r(xmax, ymax);
uint32_t dr = inf;
// slow, could use a set here instead
for ( size_t y=0; y<ymax; ++y )
for ( size_t x=0; x<xmax; ++x ) {
node i(x, y);
uint32_t di = getdist(i);
if ( !isvisited(i) && di < dr ) {
r = i;
dr = di;
}
}
return r;
}
