最短路径

图论中的经典算法，分为：SSSP(单源最短路径)和APSP(所有点对之间的最短路径)。

SSSP是指在具有V个顶点，E条边的图G中，从某一顶点Vi出发，到其余任意一顶点Vj的最短路径。

常用算法为：Dijkstra算法，Bellman-Ford算法和SPFA算法。

Dijkstra算法：假设图为不带负权的有向图或无向图，利用贪心的策略，每次新扩展一个距离最短的点，再以这个为中间点，更新其他所有点的距离。感觉和最小生成树的Prim算法差不多，最小生成树的博文请点这里。记住：这个算法只适用于非负权值的有向图最优路径问题。

算法流程，假设s为源，map[u,v]为点u和v之间的边的权值，保存在Dist[]中。

        开始初始化源的距离Dist[s]为0，其他的点距离设为无穷大，同时把所有的点的状态设为没有被访问过。然后循环n-1次：

        在没有被访问过的点中取一距离最小的点u，并将其状态设为已被访问。然后对于每个与u相邻的点v，如果Dist[u]+map[u,v]<Dist[v]，那么把Dist[v]更新成更短的距离Dist[u]+map[u,v]。此时到点v的最短路径上，前一个节点即为u。这个时候对于任意的u，dist[u]就是s到u的距离。

还是以例题讲解，见NYOJ 115(城市平乱)，标准的Diskstra算法，模板见代码，我把那个最大值设为0x7fffffff错了好多次，总是会出现负数：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX=1010;
const int Inf=100010;
#define min(a,b) a<b?a:b
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int num,n,m,P,Q,force[MAX],visit[MAX],Dist[MAX],map[MAX][MAX];
void Dijkstra(int pos) //计算点S到其它顶点的最短路径，保存在Dist[]数组中 
{   CLR(visit,0);
    for(int i=1;i<=m;i++)
        Dist[i]=map[pos][i]; 
    Dist[pos]=0;
    visit[pos]=1;
    for(int i=1;i<m;i++)
    {   int Min=Inf;
        for(int j=1;j<=m;j++)
            if(!visit[j]&&Min>Dist[j]) Min=Dist[pos=j]; 
        visit[pos]=1;
        for(int j=1;j<=m;j++)
            if(!visit[j]) Dist[j]=min(Dist[j],Dist[pos]+map[pos][j]);//更新点pos到任意位置的最短距离,看直接到j,和通过pos到j的距离那个小    
    }    
}
int main()
{   scanf("%d",&num);
    while(num--)
    {   for(int i=0;i<MAX;i++)
            fill(map[i],map[i]+MAX,Inf);
        scanf("%d%d%d%d",&n,&m,&P,&Q);
        for(int i=1;i<=n;i++)
            scanf("%d",&force[i]);
        for(int i=1;i<=P;i++)
        {   int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            map[u][v]=map[v][u]=w;
        }
        int Min=Inf;
        Dijkstra(Q);
        for(int i=1;i<=n;i++)
            Min=min(Min,Dist[force[i]]);
        printf("%d\n",Min);     
    }  
    return 0;
} 

这个算法可以使用STL中的优先队列进行优化，具体见标准程序。

#include<iostream>
#include<climits>
#include<cstring>
#include<cstdio>
#include<vector>
#include<iterator>
#include<queue>
using namespace std;
const int MAX=1010;
int len[MAX];
bool visited[MAX];
int n,m,p,q,a,b,d;
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > dq;
struct Node
{
	Node(int num,int dis):num(num),dis(dis){}
	int num,dis;
};
void Dijkstra(vector<vector<Node> >& g) //优先队列实现Dijkstra
{
	pair<int,int> tp;
	while(!dq.empty())
	{
		tp=dq.top();dq.pop();
		if(tp.second==q-1) return; //剪枝
		if(tp.first!=len[tp.second]) continue;
		visited[tp.second]=true;
		for(int j=0;j!=g[tp.second].size();++j)
			if(tp.first+g[tp.second][j].dis<len[g[tp.second][j].num])
			{
				len[g[tp.second][j].num]=tp.first+g[tp.second][j].dis;
				dq.push(make_pair(len[g[tp.second][j].num],g[tp.second][j].num));
			}
	}
}

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		while(!dq.empty()) dq.pop();
		cin>>n>>m>>p>>q;
		vector<vector<Node> > g(m);
		for(int i=0;i!=g.size();i++) len[i]=INT_MAX;
		for(int i=0;i!=n;i++)
		{
			cin>>a;
			len[a-1]=0;
			dq.push(make_pair(0,a-1));
		}
		for(int i=0;i!=p;++i)
		{
			scanf("%d%d%d",&a,&b,&d);
			g[a-1].push_back(Node(b-1,d));
			g[b-1].push_back(Node(a-1,d));
		}
		Dijkstra(g);
		cout<<len[q-1]<<endl;
		memset(len,0,sizeof(len));
		memset(visited,0,sizeof(visited));
	}
	return 0;
}        

算法2，Bellman-Ford算法：这个算法可以判断图中是否有负权回路，同时该算法也可以用来求解负权情况下的单源最短路径问题。
假设Dist[pos]表示pos到其它顶点的最短距离，然后采用松弛技术，对每条边(Vi,Vj)进行|V|-1次松弛操作，每次Dist[Vi]+(Vi,Vj)<Dist[Vj]时，更新Dist[Vj]的值为Dist[Vi]+(Vi,Vj)，|V|-1次松弛操作后，如果还存在Dist[Vi]+(Vi,Vj)<Dist[Vj]，表示图中存在负权回路，返回错误信息，否则Dist[Vj]表示到源点pos最短距离。 
初始化的时候将除源点外的所有顶点的最短距离设为d[v] 赋值为∞, 源点d[s] =0; 

要注意的是这个题目是无向图，注意双向连通，不然的话得不出结果的，我就是这样做了好久~~~具体见代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX=1010;
const int MAXN=200001;
const int Inf=1000000;
#define min(a,b) a<b?a:b
int num,n,m,P,Q,Dist[MAX],force[MAX],map[MAX][MAX];
struct Graph{
    void Copy(Graph &G1,Graph &G2)
    {   G1.u=G2.v,G1.v=G2.u,G1.w=G2.w;
    }
    int u,v,w;  
}G[MAXN],g;    
bool Bellman_Ford()
{   fill(Dist,Dist+MAX,Inf);
    Dist[Q]=0;    
    for(int i=1;i<m;i++)//循环m-1次 
        for(int j=1;j<=2*P;j++)
            Dist[G[j].v]=min(Dist[G[j].v],Dist[G[j].u]+G[j].w);//松弛操作         
    for(int i=1;i<=2*P;i++)
        if(Dist[G[i].v]>Dist[G[i].u]+G[i].w) return false;//这个题目不用判断,不会出现负权回路 
    return true;                
}         
int main()
{   scanf("%d",&num);
    while(num--)
    {   scanf("%d%d%d%d",&n,&m,&P,&Q);
        for(int i=1;i<=n;i++)
            scanf("%d",&force[i]);
        for(int i=1;i<=P;i++)
        {   scanf("%d%d%d",&G[2*i].u,&G[2*i].v,&G[2*i].w);           
            g.Copy(G[2*i-1],G[2*i]);//无向图求最短路径,注意双向性 
        }  
        Bellman_Ford();
        int Min=Inf;
        for(int i=1;i<=n;i++)
            Min=min(Min,Dist[force[i]]); 
        printf("%d\n",Min);            
    } 
    return 0;
}

算法3，SPFA算法，后面的博文中有。