最短路问题模板+解释+路径还原

1.Bellman-Ford:

求单源最短路问题。优点可以求解有负边的情况。

d[i] = min{d[j]+(j到i的边的权值)|e(j,i)E}

畅通工程续+模板

#include<iostream>
#include<stdio.h>
using namespace std;
struct edge{
	int from;
	int to; 
	int cost;
};//由顶点from指向顶点to的距离为cost
edge es[1100];
int N,M,S,T,d[1100];
const int INF = 99999999;
void short_path(int s)
{
	for(int i = 0;i<N;i++)
	{
		d[i] = INF;
	}//距离初始为INF
	d[s] = 0;
	while(true)
	{
		bool update = false;//判断是否结束
		for(int i = 0;i<2*M;i++)
		{
			edge e = es[i];
			if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost)//不断更新
		 	{
				d[e.to] = d[e.from]+e.cost;
				update = true; 		
			} 
		}
                //update = false时一定不再存在符合条件的情况因而退出
		if(!update)
		{
			break;
		}	  
	}	
}

int main()
{
	while(scanf("%d%d",&N,&M)!=EOF)
	{
		for(int i = 0;i<2*M;i++)
		{
			scanf("%d%d%d",&es[i].from,&es[i].to,&es[i].cost);
			i++;
			es[i].from = es[i-1].to;es[i].to = es[i-1].from;es[i].cost = es[i-1].cost;
		}
		scanf("%d%d",&S,&T);
		short_path(S);
		if(d[T]==INF)
			printf("-1\n");
		else 
			printf("%d\n",d[T]);
	}
	
	return 0;
} 

2.SPFA

队列优化算法

同样的畅通工程续+模板

#include<iostream>
#include<vector>
#include<queue>
#include<stdio.h>
const int maxn = 1100;
const int INF = 99999999;
using namespace std;
int N,M,S,T;
typedef pair<int,int>P;//first 指向点，second存cost 
vector<P> G[maxn];//vector建立邻接表
int d[maxn],v[maxn];
void spfa(int s)
{
	queue<int>que;
	fill(d,d+N+1,INF);
	fill(v,v+N+1,0);
	que.push(s);//建立队列将更新过的结点传入
	d[s] = 0;
	v[s] = 1;
	while(!que.empty())
	{
		int a = que.front();
		que.pop();
		v[a] = 0;//将该点放出表示又可以加入队列，当然要在他再一次更新后
		for(int i = 0;i<G[a].size();i++)
		{
			int temp = G[a][i].first;
			if(d[temp]>d[a]+G[a][i].second)
			{
				d[temp] = d[a]+G[a][i].second;
				if(v[temp] == 0)
				{
					que.push(temp);//更新了temp并将其放入队列
					v[temp] = 1;。。记录下子防止重复加入
				}
			} 
		}
	}
}
int main()
{
	
	while(scanf("%d%d",&N,&M)!=EOF)
	{
		for(int i = 0;i<=N;i++)
			G[i].clear();
		for(int i = 0;i<M;i++)
		{
			int x,y,cost;
			scanf("%d%d%d",&x,&y,&cost);
			G[x].push_back(P(y,cost));
			G[y].push_back(P(x,cost));
		}
		scanf("%d%d",&S,&T);
		spfa(S);
		if(d[T] == INF)
		{
			printf("-1\n");
		}
		else
			printf("%d\n",d[T]);
	}
	return 0;
} 

3.Dijkstra算法

没有负边的情况

（1）找到最短距离已经确定的顶点，从他出发更新相邻顶点的最短路径。

（2）此后不用再关心1中的"最短距离已经确定的顶点"。

可以想象一下既然他是在所有顶点中最短的，就不可能通过其他顶点更新来的距离比他短。

最短路题目+模板

#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn = 110;
const int INF = 99999999;
int cost[maxn][maxn],used[maxn],dis[maxn];
int N,M;
void dijkstra(int s)
{
    fill(dis,dis+N+1,INF);
    fill(used,used+N+1,false);
    dis[s] = 0;
    while(true)
    {
        int v = -1;
        //从尚未使用过的顶点选择一个最小的来更新其他顶点并重复
        for(int i = 1;i<=N;i++)
        {
            if(!used[i]&&(v == -1||dis[i]<dis[v]))
            {
                v = i;
            }
        }
        if(v == -1)
            break;//停下循环的条件已经不再含有未使用过的定点
        used[v] = true;
        for(int i = 1;i<=N;i++)
        {
            dis[i] = min(dis[i],dis[v]+cost[v][i]);
        }
    }
}
int main()
{
    while(scanf("%d%d",&N,&M)!=EOF)
    {
        if(N == 0&&M==0)
            break;
        for(int i = 0;i<=N;i++)
        {
            for(int j = 0;j<=N;j++)
            {
                cost[i][j] = INF;
                if(i == j)
                    cost[i][j] = 0;
            }
        }
        for(int i = 0;i<M;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(cost[a][b]>c)
            {
                cost[a][b] = cost[b][a] = c;
            }
        }
        dijkstra(1);
        cout<<dis[N]<<endl; 
    }
    return 0;
}

堆优化及优先队列优化问题。算法复杂度O(|E|log|V|）

同样的是上面的最短路问题+模板

#include<stdio.h>
#include<math.h>
#include<vector>
#include<queue> 
//#include<greater>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn = 110;
const int INF = 99999999;
struct edge{
	int to;
	int cost;
};
vector<edge> G[maxn];
int N,M,d[maxn];
typedef pair<int,int> P;
void dijkstra(int s)
{
	priority_queue<P,vector<P>,greater<P> >que;
	fill(d,d+N+1,INF);
	d[s] = 0;
	que.push(P(0,s));
	while(!que.empty())
	{
		P p = que.top();que.pop();
		int v = p.second;
		if(d[v]<p.first)
			continue;
		for(int i = 0;i<G[v].size();i++)
		{
			edge e = G[v][i];
			if(d[e.to]>d[v]+e.cost)
			{
				d[e.to] = d[v]+e.cost;
				que.push(P(d[e.to],e.to));
			}
		}
	}
}
int main()
{
    while(scanf("%d%d",&N,&M)!=EOF)
    {
        if(N == 0&&M==0)
            break;
        for(int i = 0;i<=N;i++)
        {
        	G[i].clear();
		}
        for(int i = 0;i<M;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            edge e;
            e.to = b;e.cost = c;
			G[a].push_back(e);
			e.to = a;
			G[b].push_back(e);
        }
        dijkstra(1);
        cout<<d[N]<<endl; 
    }
    return 0;
}

4.Floyd

可求多源最短路各个点间的最短路复杂度O（n^3)

void Floyd()
{
    for(int k = 0;k<V;k++)
        for(int i = 0;i<V;i++)
            for(int j = 0;j<V;j++)

                d[i][j] = min(d[i][j],d[i][k]+d[k][j]);

}

5.路径还原

int pre[maxn];
void dijkstra(int s)
{
	fill(d,d+V,INF);
	fill(used,used+V,0);
	fill(prev,prev+V,-1);
	d[s] = 0;
	while(true)
	{
		int v = -1;
		for(int u = 0;u<V;u++)
		{
			if(!used[u]&&(v == -1||d[u]<d[v]))
			{
				v = u;
			}
		}
		if(v == -1)
			break;
		used[v] = true;
		for(int u = 0;u<V;u++)
		{
			if(d[u]>d[u]+cost[v][u])
			{
				d[u] = d[v]+cost[v][u];
				pre[u] = v;
			}
		}
	}
}
vector<int>get_path(int t)
{
	vector<int>path;
	for(;t!=-1;t = prev[t]) 
		path.push_back(t);//不断沿着prev[t]走指导t = s;
	reverse(path.begin(),path.end());
	return path; 
}