题意是这样的，给你一个无向图，
每条边有距离和花费，
如果从第一个点到末点的最短路不唯一，
则输出最短路长度以及最少的花费。
否则输出长度和花费就行。

用传说中的链式向前星优化了一下边的存储，

写了个spfa解这道题。

链式向前星，是个静态链表。

是这样实现的，用一个数组box存放

跟所有起始点相连的最后一个存入的终点在

side结构数组中的下标是，

然后用side[i].next存放相同起始点的下一个终点。

我的代码如下：

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
int cnt,num_dot,num_side,st,ed,dis[1010],cos[1010],box[1010];
struct node
{
	int to,next,d,c;
}side[200010];
void add(int from,int to,int d,int c)
{
	side[cnt].to=to;
	side[cnt].d=d;
	side[cnt].c=c;
	side[cnt].next=box[from];
	box[from]=cnt++;
}
void init()
{
	int s,e,d,c;
	cnt=0;
	memset(box,-1,sizeof(box));
	for(int i=0;i<num_side;i++)
	{
		scanf("%d%d%d%d",&s,&e,&d,&c);
		add(s,e,d,c);
		add(e,s,d,c);
	}
	scanf("%d%d",&st,&ed);
}
void spfa()
{
	int mid;
	bool iq[1010];
	queue<int>qq;
	memset(iq,0,sizeof(iq));
	memset(dis,127,sizeof(dis));
	memset(cos,127,sizeof(cos));
	iq[st]=1;
	dis[st]=0;
	cos[st]=0;
	qq.push(st);
	while(qq.size())
	{
		mid=qq.front();
		qq.pop();
		iq[mid]=0;
		for(int i=box[mid];i>-1;i=side[i].next)
		{
			if(dis[side[i].to]>dis[mid]+side[i].d)
			{
				dis[side[i].to]=dis[mid]+side[i].d;
				cos[side[i].to]=cos[mid]+side[i].c;
				if(!iq[side[i].to])
				{
					qq.push(side[i].to);
					iq[side[i].to]=1;
				}
			}
			else if(dis[side[i].to]==dis[mid]+side[i].d&&cos[side[i].to]>cos[mid]+side[i].c)
			{
				cos[side[i].to]=cos[mid]+side[i].c;
				if(!iq[side[i].to])
				{
					qq.push(side[i].to);
					iq[side[i].to]=1;
				}
			}
		}
	}
}
int main()
{
	while(scanf("%d%d",&num_dot,&num_side)&&(num_dot!=0||num_side!=0))
	{
		init();
		spfa();
		printf("%d %d\n",dis[ed],cos[ed]);
	}
}