UVa 10075 - Airlines

题目：给出地球上一些点的经度和纬度，以及地点之间是否直达的航班，然后询问两地间最短的行程。

分析：计算几何、最短路、字符串、hash。

            首先，利用hash建立地名（单词）和编号的映射；

            然后，将大地坐标转换，求出有直达航班地点之间的球面最短距离；

            d = r*sqrt(2-2*(cos(lat1)*cos(lat2)*cos(lon1-lon2)+sin(lat1)*sin(lat2)) （推导见11817）

            最后，利用floyd计算所有点间的最短距离，查询输出即可。

注意：1.有向图；2.距离取整要在计算最短路之前（四舍五入）；

            3.早上起来改用了不同版本的最短路算法，效率差强人意，效率和代码如下：

               T：dijkstra+斐波那契堆 < spfa+stack < dijkstra+二叉堆 = floyd < dijkstra+二项堆 = TLE。

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>

using namespace std;

//hash__begin
typedef struct hnode
{
	int    id;
	char   name[ 21 ];
	hnode* next;
}hnode;
hnode* List[ 257 ];
hnode  Node[ 105 ];
int table[20]={	13,17,31,71,131,171,313,717,1313,1717,
				3131,7171,13131,17171,31313,71717,131313,
				171717,313131,717171};

class hash {
	int size;
public:
	hash() {
		size = 0;
		memset( List, 0, sizeof(List) );
	}
	//计算hash值 
	int calc( char* str ) {
		int value = 0;
		for ( int i = 0 ; str[i] ; ++ i )
			value = (value+str[i]*table[i])%257;
		return value;
	}
	//插入 
	void insert( char* str, int id ) {
		int value = calc(str);
		Node[size].next = List[value];  
    	Node[size].id   = id;
    	List[value] = &Node[size];  
    	strcpy(Node[size ++].name,str);
	}
	//查询 
	int find( char* str ) {
		int value = calc(str);
		for ( hnode* p = List[value] ; p ; p = p->next )
			if ( !strcmp( str, p->name ) )
				return p->id;
	}
};
//hash__end

char   name[105][21];
char   city1[21],city2[21];
double lat[105],lon[105],dis;
int    path[105][105];

//大地坐标转化 
int dist( double l1, double d1, double l2, double d2 )
{
	double r = 6378;
	double p = 3.141592653589793;
	l1 *= p/180.0; 
	l2 *= p/180.0;
	d1 *= p/180.0; 
	d2 *= p/180.0;
	double d = r*sqrt(2-2*(cos(l1)*cos(l2)*cos(d1-d2)+sin(l1)*sin(l2)));
	return (int)(0.5+2*asin(d/(2*r))*r);	
}

//floyd计算多元最短路 
void floyd( int n )
{
	for ( int k = 0 ; k < n ; ++ k )
	for ( int i = 0 ; i < n ; ++ i )
	for ( int j = 0 ; j < n ; ++ j )
	    if ( path[i][k] != -1 && path[k][j] != -1 )
	    if ( path[i][j] == -1 || path[i][j] > path[i][k] + path[k][j] )
	    	path[i][j] = path[i][k] + path[k][j];
}

int main()
{
	int N,M,Q,id1,id2,T = 1;
	while ( ~scanf("%d%d%d",&N,&M,&Q) && N+M+Q ) {
		if ( T > 1 ) printf("\n");
		printf("Case #%d\n",T ++);
		
		//输入数据到hash表 
		hash Hash;
		for ( int i = 0 ; i < N ; ++ i ) {
			scanf("%s%lf%lf",name[i],&lat[i],&lon[i]);
			Hash.insert( name[i], i );
		}
		
		//初始化距离，只计算可直达 
		for ( int i = 0 ; i < N ; ++ i )
		for ( int j = 0 ; j < N ; ++ j )
			path[i][j] = -1;
		for ( int i = 0 ; i < M ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			path[id1][id2] = dist( lat[id1], lon[id1], lat[id2], lon[id2] );
		}
		
		//计算有向图多元最短路 
		floyd( N );
		
		//查询输出 
		for ( int i = 0 ; i < Q ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			if ( path[id1][id2] == -1 )
				printf("no route exists\n");
			else printf("%d km\n",path[id1][id2]);
		}
	}
	return 0;
}

早上起来，改了不同的最短路算法，发现效率没有明显提高，╮(╯▽╰)╭。

spfa版本：

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>

using namespace std;

const int MAX_LENGTH = 5000000;

//hash__begin
typedef struct hnode
{
	int    id;
	char   name[ 21 ];
	hnode* next;
}hnode;
int table[20]={	13,17,31,71,131,171,313,717,1313,1717,
				3131,7171,13131,17171,31313,71717,131313,
				171717,313131,717171};

class hash {
	int    size;
	hnode* List[ 257 ];
	hnode  Node[ 105 ];
public:
	hash() {
		size = 0;
		memset( List, 0, sizeof(List) );
	}
	//计算hash值 
	int calc( char* str ) {
		int value = 0;
		for ( int i = 0 ; str[i] ; ++ i )
			value = (value+str[i]*table[i])%257;
		return value;
	}
	//插入 
	void insert( char* str, int id ) {
		int value = calc(str);
		Node[size].next = List[value];  
    	Node[size].id   = id;
    	List[value] = &Node[size];  
    	strcpy(Node[size ++].name,str);
	}
	//查询 
	int find( char* str ) {
		int value = calc(str);
		for ( hnode* p = List[value] ; p ; p = p->next )
			if ( !strcmp( str, p->name ) )
				return p->id;
	}
};
//hash__end

char   name[105][21];
char   city1[21],city2[21];
double lat[105],lon[105],dis;
int    path[105][105];

//大地坐标转化 
int dist( double l1, double d1, double l2, double d2 )
{
	double r = 6378;
	double p = 3.141592653589793;
	l1 *= p/180.0; 
	l2 *= p/180.0;
	d1 *= p/180.0; 
	d2 *= p/180.0;
	double d = r*sqrt(2-2*(cos(l1)*cos(l2)*cos(d1-d2)+sin(l1)*sin(l2)));
	return (int)(0.5+2*asin(d/(2*r))*r);	
}

//邻接表
typedef struct nodeg 
{
	int    point;
	int    length;
	nodeg* next;
}graph ;
graph* Head[105];
graph  Edge[305];
int    Count;
int    visit[105];
//初始化 
void initgraph( int n )
{
	for ( int i = 0 ; i < n ; ++ i )
	for ( int j = 0 ; j < n ; ++ j )
		path[i][j] = MAX_LENGTH;
	for ( int i = 0 ; i < n ; ++ i )
		path[i][i] = 0;
	for ( int i = 0 ; i < n ; ++ i )
		visit[i] = 0;
	for ( int i = 0 ; i < n ; ++ i )
		Head[i] = NULL;
	Count = 0;
}
//插入边 
void addedge( int point1, int point2, int length )
{
	Edge[Count].point  = point2;
	Edge[Count].length = length;
	Edge[Count].next   = Head[point1];
	Head[point1] = &Edge[Count ++];
}
//邻接表 end 

//SPFA计算最短路径 
int Stack[105];
int spfa( int s, int t, int n )
{	
	Stack[0] = s;
	visit[s] = 1;
	int top  = 1;
	while ( top ) {
		int now = Stack[-- top];
		for ( graph* p = Head[now] ; p ; p = p->next ) 
			if ( path[s][p->point] > path[s][now] + p->length ) {
				path[s][p->point] = path[s][now] + p->length;
				if ( !visit[p->point] ) {
					visit[p->point] = 1;
					Stack[top ++] = p->point;
				}
			}
		visit[now] = 0;
	}
	return path[s][t];
}

int main()
{
	int N,M,Q,id1,id2,T = 1;
	while ( ~scanf("%d%d%d",&N,&M,&Q) && N+M+Q ) {
		if ( T > 1 ) printf("\n");
		printf("Case #%d\n",T ++);
		
		//输入数据到hash表 
		hash Hash;
		for ( int i = 0 ; i < N ; ++ i ) {
			scanf("%s%lf%lf",name[i],&lat[i],&lon[i]);
			Hash.insert( name[i], i );
		}
		
		//初始化距离，只计算可直达 
		initgraph( N );
		for ( int i = 0 ; i < M ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			addedge( id1, id2, dist( lat[id1], lon[id1], lat[id2], lon[id2] ) );
		}
		
		//计算有向图多元最短路 
		for ( int i = 0 ; i < N ; ++ i )
			spfa( i, i, N );
		
		//查询输出 
		for ( int i = 0 ; i < Q ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			if ( path[id1][id2] == MAX_LENGTH )
				printf("no route exists\n");
			else printf("%d km\n",path[id1][id2]);
		}
	}
	return 0;
}

dijkstra+bearny_heap版本：

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>

using namespace std;

const int MAX_LENGTH = 5000000;

//hash__begin
typedef struct hnode
{
	int    id;
	char   name[ 21 ];
	hnode* next;
}hnode;
int table[20]={	13,17,31,71,131,171,313,717,1313,1717,
				3131,7171,13131,17171,31313,71717,131313,
				171717,313131,717171};

class hash {
	int    size;
	hnode* List[ 257 ];
	hnode  Node[ 105 ];
public:
	hash() {
		size = 0;
		memset( List, 0, sizeof(List) );
	}
	//计算hash值 
	int calc( char* str ) {
		int value = 0;
		for ( int i = 0 ; str[i] ; ++ i )
			value = (value+str[i]*table[i])%257;
		return value;
	}
	//插入 
	void insert( char* str, int id ) {
		int value = calc(str);
		Node[size].next = List[value];  
    	Node[size].id   = id;
    	List[value] = &Node[size];  
    	strcpy(Node[size ++].name,str);
	}
	//查询 
	int find( char* str ) {
		int value = calc(str);
		for ( hnode* p = List[value] ; p ; p = p->next )
			if ( !strcmp( str, p->name ) )
				return p->id;
	}
};
//hash__end

char   name[105][21];
char   city1[21],city2[21];
double lat[105],lon[105],dis;
int    path[105][105];

//大地坐标转化 
int dist( double l1, double d1, double l2, double d2 )
{
	double r = 6378;
	double p = 3.141592653589793;
	l1 *= p/180.0; 
	l2 *= p/180.0;
	d1 *= p/180.0; 
	d2 *= p/180.0;
	double d = r*sqrt(2-2*(cos(l1)*cos(l2)*cos(d1-d2)+sin(l1)*sin(l2)));
	return (int)(0.5+2*asin(d/(2*r))*r);	
}

//邻接表
typedef struct nodeg 
{
	int    point;
	int    length;
	nodeg* next;
}graph ;
graph* Head[105];
graph  Edge[305];
int    Count;
int    visit[105];
//初始化 
void initgraph( int n )
{
	for ( int i = 0 ; i < n ; ++ i )
	for ( int j = 0 ; j < n ; ++ j )
		path[i][j] = MAX_LENGTH;
	for ( int i = 0 ; i < n ; ++ i )
		path[i][i] = 0;
	for ( int i = 0 ; i < n ; ++ i )
		visit[i] = 0;
	for ( int i = 0 ; i < n ; ++ i )
		Head[i] = NULL;
	Count = 0;
}
//插入边 
void addedge( int point1, int point2, int length )
{
	Edge[Count].point  = point2;
	Edge[Count].length = length;
	Edge[Count].next   = Head[point1];
	Head[point1] = &Edge[Count ++];
}
//邻接表 end 

//heap
class banery_heap
{
	private:
		int  size;
		int  keys[105];
		int  base[105];
		int  In_h[105];
	public:
		banery_heap( int count = 100 ) {clear();}
		void clear() {
			size = 0;
			memset( base, 0, sizeof( base ) );
			memset( keys, 0, sizeof( keys ) );
			memset( In_h, 0, sizeof( In_h ) );
		}
		bool empty(){return size == 0;}
		void Insert( int ID, int Key ) {
			if ( !In_h[ID] ) {
				In_h[ID] = ++ size;
				base[size] = ID;
			}
			keys[In_h[ID]] = Key;
			int now = In_h[ID];
			while ( now > 1 && keys[now] < keys[now>>1] ) {
				swap( base[now], base[now>>1] );
				swap( keys[now], keys[now>>1] );
				swap( In_h[base[now]], In_h[base[now>>1]] );
				now = now>>1;
			}
		}
		int Delete( void ) {
			swap( base[size], base[1] );
			swap( keys[size], keys[1] );
			swap( In_h[base[size]], In_h[base[1]] );
			int now = 1;
			while ( 1 ) {
				int New = now,L = (now<<1),R = (now<<1)+1;
				if ( L < size && keys[L] < keys[New] ) New = L;
				if ( R < size && keys[R] < keys[New] ) New = R;
				if ( now == New ) break;
				swap( base[now], base[New] );
				swap( keys[now], keys[New] );
				swap( In_h[base[now]], In_h[base[New]] );
				now = New;
			}
			return base[size --];
		}
}Heap;
//heap end

void dijkstra( int s, int n )
{
	Heap.clear();
	Heap.Insert( s, 0 );
	while ( !Heap.empty() ) {
		int now = Heap.Delete();
		for ( graph* p = Head[now] ; p ; p = p->next )
			if ( path[s][p->point] > path[s][now] + p->length ) {
				path[s][p->point] = path[s][now] + p->length;
				Heap.Insert( p->point, path[s][p->point] );
			}
	}
}

int main()
{
	int N,M,Q,id1,id2,T = 1;
	while ( ~scanf("%d%d%d",&N,&M,&Q) && N+M+Q ) {
		if ( T > 1 ) printf("\n");
		printf("Case #%d\n",T ++);
		
		//输入数据到hash表 
		hash Hash;
		for ( int i = 0 ; i < N ; ++ i ) {
			scanf("%s%lf%lf",name[i],&lat[i],&lon[i]);
			Hash.insert( name[i], i );
		}
		
		//初始化距离，只计算可直达 
		initgraph( N );
		for ( int i = 0 ; i < M ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			addedge( id1, id2, dist( lat[id1], lon[id1], lat[id2], lon[id2] ) );
		}
		
		//计算有向图多元最短路 
		for ( int i = 0 ; i < N ; ++ i )
			spfa( i, N );
		
		//查询输出 
		for ( int i = 0 ; i < Q ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			if ( path[id1][id2] == MAX_LENGTH )
				printf("no route exists\n");
			else printf("%d km\n",path[id1][id2]);
		}
	}
	return 0;
}

dijkstra+fibonacci_heap版本：

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>

using namespace std;

const int MAX_LENGTH = 5000000;

//hash__begin
typedef struct hnode
{
	int    id;
	char   name[ 21 ];
	hnode* next;
}hnode;
int table[20]={	13,17,31,71,131,171,313,717,1313,1717,
				3131,7171,13131,17171,31313,71717,131313,
				171717,313131,717171};

class hash {
	int    size;
	hnode* List[ 257 ];
	hnode  Node[ 105 ];
public:
	hash() {
		size = 0;
		memset( List, 0, sizeof(List) );
	}
	//计算hash值 
	int calc( char* str ) {
		int value = 0;
		for ( int i = 0 ; str[i] ; ++ i )
			value = (value+str[i]*table[i])%257;
		return value;
	}
	//插入 
	void insert( char* str, int id ) {
		int value = calc(str);
		Node[size].next = List[value];  
    	Node[size].id   = id;
    	List[value] = &Node[size];  
    	strcpy(Node[size ++].name,str);
	}
	//查询 
	int find( char* str ) {
		int value = calc(str);
		for ( hnode* p = List[value] ; p ; p = p->next )
			if ( !strcmp( str, p->name ) )
				return p->id;
	}
};
//hash__end

char   name[105][21];
char   city1[21],city2[21];
double lat[105],lon[105],dis;
int    path[105][105];

//大地坐标转化 
int dist( double l1, double d1, double l2, double d2 )
{
	double r = 6378;
	double p = 3.141592653589793;
	l1 *= p/180.0; 
	l2 *= p/180.0;
	d1 *= p/180.0; 
	d2 *= p/180.0;
	double d = r*sqrt(2-2*(cos(l1)*cos(l2)*cos(d1-d2)+sin(l1)*sin(l2)));
	return (int)(0.5+2*asin(d/(2*r))*r);	
}

//邻接表
typedef struct gnode
{
	int    point;
	int    length;
	gnode* next;
}graph ;
graph* Head[105];
graph  Edge[305];
int    Count;
int    visit[105];
//初始化 
void initgraph( int n )
{
	for ( int i = 0 ; i < n ; ++ i )
	for ( int j = 0 ; j < n ; ++ j )
		path[i][j] = MAX_LENGTH;
	for ( int i = 0 ; i < n ; ++ i )
		path[i][i] = 0;
	for ( int i = 0 ; i < n ; ++ i )
		visit[i] = 0;
	for ( int i = 0 ; i < n ; ++ i )
		Head[i] = NULL;
	Count = 0;
}
//插入边 
void addedge( int point1, int point2, int length )
{
	Edge[Count].point  = point2;
	Edge[Count].length = length;
	Edge[Count].next   = Head[point1];
	Head[point1] = &Edge[Count ++];
}
//邻接表 end 

//fibonacci_heap
typedef struct node_fib
{
	int       key,id;
	bool      mark;
	short     degree;
	node_fib* left;
	node_fib* right;
	node_fib* child;
	node_fib* father;
}fib_node;

typedef struct node_arr
{
	short     degree;
	node_fib* addr;
	node_arr* next;
}arr_node;

class fibonacci_heap
{
	private:
		fib_node* root;
		fib_node* base;
		fib_node**space;
		arr_node* array;
		arr_node**ahead;
		int       count;
		fib_node* newNode( int ID, int K );
		void Link( fib_node* q, fib_node* p );
		void Union( fib_node* r, fib_node* q );
		void Cut( fib_node* p );
		void Consolidate( fib_node* h );
	public:
		fibonacci_heap();
		void clear();
		bool empty( void ) {return (!root);}
		void Insert( int ID, int K );
		int  Delete( void );
}Heap;
fibonacci_heap::fibonacci_heap() {
	base  = new fib_node  [100];
	space = new fib_node* [100];
	array = new arr_node  [100];
	ahead = new arr_node* [100];
	clear();
}
void fibonacci_heap::clear() {
	root  = 0; count = 0;
	memset( base , 0, sizeof( fib_node  )*100 ); 
	memset( space, 0, sizeof( fib_node* )*100 );
	memset( array, 0, sizeof( arr_node  )*100 ); 
	memset( ahead, 0, sizeof( arr_node* )*100 );
} 
fib_node* fibonacci_heap::newNode( int ID, int K ) {
	fib_node* np = &base[ count ++ ];
	np->left = np->right = np;
	np->id = ID; np->key = K;
	space[ ID ] = np;
	return np;
}
void fibonacci_heap::Link( fib_node* q, fib_node* p ) {//p to q
	if ( !q->child ) q->child = p;
	else Union( q->child, p );
	p->father = q;
	q->degree ++ ;
}
void fibonacci_heap::Union( fib_node* r, fib_node* q ) {
	fib_node* p = q->right;
	p->left = r;
	q->right = r->right;
	r->right->left = q;
	r->right = p;
}
void fibonacci_heap::Cut( fib_node* p ) {
	if ( !p ) return;
	if ( p == root ) {root=NULL;return;}
	if ( p->father ) {
		p->father->degree --;
		if ( !p->father->mark ) p->father->mark = true;
		if ( p->father->child->left == p->father->child )
			p->father->child = NULL;
		else p->father->child = p->left;
	}
	fib_node* q = p->left;
	q->right = p->right;
	p->right->left = q;
	p->left = p->right = p;
	p->father = NULL;
	p->mark = false;
}
void fibonacci_heap::Insert( int ID, int K ) {
	if ( !space[ ID ] ) {
		fib_node* np = newNode( ID, K );
		if ( !root ) root = np;
		else {
			Union( root, np );
			if ( K < root->key ) root = np;
		}
	}else {
		fib_node* np = space[ ID ];
		fib_node* fp = NULL;
		if ( np->key < K ) return;
		np->key = K;
		if ( np->father && K < np->father->key ) {
			do {
				fp = np->father;
				Cut( np );
				if ( !root ) root = np;
				else Union( root, np );
				np = fp;
			}while ( np && np->mark && np != root );
			if ( np ) np->mark = true;//
		}
		if ( K < root->key ) root = space[ ID ];
	}
}
void fibonacci_heap::Consolidate( fib_node* h ) {
	int number = 0,maxdeg = 0,id = 0;
	if ( !h ) return;
	array[ number ].degree = maxdeg = h->degree;
	array[ number ].addr = h;
	for ( fib_node *p = h->left ; p != h ; p = p->left ) {
		++ number;
		array[ number ].degree = p->degree;
		array[ number ].addr = p;
		if ( maxdeg < p->degree ) maxdeg = p->degree;
	}
	if ( !number ) return;
	
	for ( int i = 0 ; i <= maxdeg ; ++ i )
		ahead[ i ] = NULL;
	for ( int i = 0 ; i <= number ; ++ i ) {
		id = array[ i ].degree;
		array[ i ].next = ahead[ id ];
		ahead[ id ] = &array[ i ];
	}
	arr_node *ap, *aq;
	for ( int i = 0 ; i <= maxdeg ; ++ i ) 
	for ( ap = ahead[ i ] ; ap && ap->next ; ) {
		aq = ap->next;
		ahead[ i ] = aq->next;
		if ( !(ap->addr->key < aq->addr->key) && ap->addr != root )
			swap( ap->addr, aq->addr );
		Cut( aq->addr );
		Link( ap->addr, aq->addr );
		ap->next = ahead[ i+1 ];
		ahead[ i+1 ] = ap;
		ap = ahead[ i ];
		if ( i == maxdeg ) ahead[ ++ maxdeg ] = NULL;
	}
}
int fibonacci_heap::Delete( void ) {
	if ( !root ) return 0;
	fib_node* np = root->child;
	fib_node* fp = NULL;
	while ( np ) {
		fp = (np->left == np)?NULL:np->left;
		Cut( np );
		Union( root, np );
		np = fp;
	}
	fib_node* answer = root;
	root->child = NULL;
	root = root->left;
	if ( root != answer ) {
		Cut( answer );
		np = root;
		for ( fp = root->left ; fp != root ; fp = fp->left )
			if ( fp->key < np->key ) np = fp;
		root = np;
		Consolidate( root );
	}else root = NULL;
	return answer->id;
}
//fibonacci_heap end

void dijkstra( int s, int n )
{
	Heap.clear();
	Heap.Insert( s, 0 );
	while ( !Heap.empty() ) {
		int now = Heap.Delete();
		for ( graph* p = Head[now] ; p ; p = p->next )
			if ( path[s][p->point] > path[s][now] + p->length ) {
				path[s][p->point] = path[s][now] + p->length;
				Heap.Insert( p->point, path[s][p->point] );
			}
	}
}

int main()
{
	int N,M,Q,id1,id2,T = 1;
	while ( ~scanf("%d%d%d",&N,&M,&Q) && N+M+Q ) {
		if ( T > 1 ) printf("\n");
		printf("Case #%d\n",T ++);
		
		//输入数据到hash表 
		hash Hash;
		for ( int i = 0 ; i < N ; ++ i ) {
			scanf("%s%lf%lf",name[i],&lat[i],&lon[i]);
			Hash.insert( name[i], i );
		}
		
		//初始化距离，只计算可直达 
		initgraph( N );
		for ( int i = 0 ; i < M ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			addedge( id1, id2, dist( lat[id1], lon[id1], lat[id2], lon[id2] ) );
		}
		
		//计算有向图多元最短路 
		for ( int i = 0 ; i < N ; ++ i )
			dijkstra( i, N );
		
		//查询输出 
		for ( int i = 0 ; i < Q ; ++ i ) {
			scanf("%s%s",city1,city2);
			id1 = Hash.find( city1 );
			id2 = Hash.find( city2 );
			if ( path[id1][id2] == MAX_LENGTH )
				printf("no route exists\n");
			else printf("%d km\n",path[id1][id2]);
		}
	}
	return 0;
}