Dijkstra（歪果仁的名字真是长。。。）

Dijkstra算法又称为单源最短路径，所谓单源是在一个有向图中，从一个顶点出发，求该顶点至所有可到达顶点的最短路径问题。 
      设G=（V，E）是一个有向图，V表示顶点，E表示边。它的每一条边（i，j）属于E，都有一个非负权W（I,j），在G中指定一个结点v0，要求把从v0到G的每一个接vj（vj属于V）的最短有向路径找出来（或者指出不存在）。
      Dijstra算法是运用贪心的策略，从源点开始，不断地通过相联通的点找出到其他点的最短距离
基本思想是：
      设置一个顶点的集合s，并不断地扩充这个集合，一个顶点属于集合s当且仅当从源点到该点的路径已求出。开始时s中仅有源点，并且调整非s中点的最短路径长度，找当前最短路径点，将其加入到集合s，直到终点在s中。
基本步骤：
1、把所有结点分成两组：
      第一组：包括已经确定最短路径的结点；
      第二组：包括尚未确定最短路径的结点。
2、开始时，第一组只包含起点，第二组包含剩余的点；
3、用贪心的策略，按最短路径长度递增的顺序把第二组的结点加到第一组去，直到v0可达的所有结点都包含于第一组中。在这个过程中，不断更新最短路径，总保持从v0到第一组各结点的最短路径长度dist都不大于从v0到第二组任何结点的路径长度。
4、每个结点对应一个距离值，第一组结点对应的距离就是v0到此结点的最短路径长度，第二组结点对应的距离值就是v0由第一组结点到此结点的最短路径长度。
5、直到所有的顶点都扫描完毕（v0可达的所有结点都包含于第一组中），找到v0到其它各点的所有最短路径。

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int INF=999999;
const int N=100;
int dis[N],c[N][N],prev[N];
int n,m;
void Dijkstra(int sta)
{
bool s[n];
memset(s,0,n);
s[sta]=1;
for(int i=1; i<=n; i++)
{
dis[i]=c[sta][i];
dis[i]==INF?prev[i]=0:prev[i]=sta;
}
dis[sta]=0;
for(int i=2; i<=n; i++)
{
int temp=INF;
int u=sta;
for(int j=1; j<=n; j++)
{
if((!s[j])&&dis[j]<temp)
{
temp=dis[j];
u=j;
}
}
s[u]=1;
for(int j=1; j<=n; j++)
{
if((!s[j])&&c[u][j]<INF)
{
if(dis[j]>dis[u]+c[u][j])
{
dis[j]=dis[u]+c[u][j];
prev[j]=u;

}
}
}
}
}
void search(int sta,int end)
{
int que[N];
int tot=1;
que[tot]=end;
tot++;
int temp=prev[end];
while(temp!=sta)
{
que[tot++]=temp;
temp=prev[temp];
}
que[tot]=sta;
for(int i=tot;i>0;i--)
i==1?cout<<que[i]<<endl:cout<<que[i]<<"->";
}
int main()
{
cin>>n>>m;
int p,q,len;
int i,j;
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
c[i][j]=INF;

while(m--)
{
cin>>p>>q>>len;
if(len<c[p][q])
{
c[p][q]=len;
c[q][p]=len;
}
}
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
printf("%8d",c[i][j]);
printf("\n");
Dijkstra(1);
cout<<dis[n]<<endl;
search(1,n);
return 0;
}

/* shuru
5
7
1 2 10
1 4 30
1 5 100
2 3 50
3 5 10
4 3 20
4 5 60
*/