最短路算法(写烂它，倒背如流）

Floyd算法一定要记住，探测点循环要放到最外层！！！！！！！！！！！！！！！

这是由其算法本身所决定的，其每一步求出任意一对顶点之间仅通过中间节点1,2,...,k的最短距离，当1,2,...,k扩展到所有顶点时，算法解出任意一对顶点间的最短距离，故顺序自然是：
for(k=1;k<n;++k)
    //枚举任意一对顶点
由其状态转移方程来看，这个算法的顺序也很清晰，应该是先计算较小的k时任意ij之间的最短距离：
dij(k) = wij  如果k=0
min(dij(k-1),dik(k-1)+dkj(k-1))   如果k>=1
其中i,j表示点对，k表示第1,2,...,k时的最短路径

const maxV = 100;  
const maxLen = 999999;  
  
int dist[maxV];  
int path[maxV];  
int length[maxV][maxV];  
int i,j;  
  
  
void Dijkstra(int v,int n)  
{  
    bool s[maxV];  
    for(i=1;i<=n;++i)  
    {  
        s[i]=0;  
        dist[i]=length[v][i];  
        if(dist[i]==maxLen)  
            path[i]=0;  
        else  
            path[i]=v;  
    }  
    s[v]=1;  
    dist[v]=0;  
    for(i=2;i<=n;++i)  
    {  
        int temp = maxLen;  
        int u = v;  
        for(j=1;j<=n;++j)  
        {  
            if(!s[j]&&dist[j]<temp)  
            {  
                u = j ;  
                temp = dist[j];  
            }  
        }  
        s[u]=1;  
        for(j=1;j<=n;j++)  
        {  
            if(!s[j]&&dist[j]>length[u][j]+dist[u])  
            {  
                path[j]=u;  
                dist[j]=length[u][j]+dist[u];  
            }  
        }  
    }  
  
  
}  
void floyd()  
{  
for(k=1;k<=n;k++) 
    for(i=1;i<=n;i++)  
        for(j=1;j<=n;j++)  
                if(length[i][k]+length[k][j]<length[i][j])  
                    length[i][j]=length[i][k]+length[k][j];  
}

Bellman-Ford 算法

#include "stdio.h"

const MaxLen=999999;
const MaxV = 1000;
const MaxE=1000;

int n,e;
int dist[MaxV];
int i,j;

struct edge
{
	int u;
	int v;
	int weight;
}edge[MaxE];

bool bellman_ford()
{
	for(i=1;i<n;i++)
	{
		for(j=1;j<=e;j++)
		{
			if(dist[edge[j].u]+edge[j].weight<dist[edge[j].v])
				dist[edge[j].v]=dist[edge[j].u]+edge[j].weight;
		}
	}
	for(j=1;j<=e;j++)
		{
			if(dist[edge[j].u]+edge[j].weight<dist[edge[j].v])
				return false;
		}
	return true;
}
int main(int argc, char* argv[])
{
	
	while(scanf("%d%d",&n,&e)!=EOF)
	{
		for(i= 1;i<=e;i++)
		{
			scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].weight);
			if(edge[i].u==1)
				dist[edge[i].v]=edge[i].weight;
			else
				dist[edge[i].v]=MaxLen;
		}	
		bellman_ford();

		for(i= 2;i<=n;i++)
		{
			printf("到%d点 %d\n",i,dist[i]);
		}

	}
	
	return 0;
}