关于最短路径的问题+Dijkstra算法的扩展

单源最短路径：

计算从一个点s到其他所有点的最短路径。

常用算法：

(1)迪杰斯特拉：(dijkstra)

朴素版：

void Dijkstra()
{
	memset(d,INF,sizeof(d));
	memset(vis,0,sizeof(vis));
	d[1]=0;
	while(1)
	{
		int u=-1,MIN=INF;
		for(int i=1;i<=n;i++)
		{
			if(!vis[i]&&d[i]<MIN)
			{
				MIN=d[i];
				u=i;
			}
		}
		if(u==-1)
			break;
		vis[u]=1;
		for(int i=1;i<=n;i++)
		{
			if(!vis[i]&&d[u]+s[u][i]<d[i])
				d[i]=d[u]+s[u][i];
		}
	}
	printf("%d\n",d[n]);
}

优先队列：

#define pr pair<int,int>

void dijkstra(int s)
{
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    memset(vis,0,sizeof(vis));
    dis[s]=0;
    priority_queue<pr,vector<pr>,greater<pr> > q;
    q.push(pr(0,s));
    while(!q.empty())
    {
        pr p=q.top();
        q.pop();
        if(vis[p.second])
            continue;
        vis[p.second]=1;
        for(int i=head[p.second];i;i=edge[i].nxt)
        {
            int to=edge[i].to;
            if(dis[to]>dis[p.second]+edge[i].dis)
            {
                dis[to]=dis[p.second]+edge[i].dis;
                q.push(pr(dis[to],to));
            }
        }
    }
}

(2)SPFA

(1)bfs版SPFA，可用来求最短路、最长路等，当然也可以用来判断负环，搞一个cnt数组，cnt[i]记录节点i的入队次数，若cnt[i]>=n则说明存在负环。但是这样的效率比较低，我们可以考虑用另外一种方式，还是搞一个cnt数组，cnt[i]记录从起点到该点的最短路径有多少个点，如果图中不存在负环，那么最多有n个点，也就是说如果出现了cnt[i]>n，说明存在负环。

void spfa()
{
	for(int i=1;i<=n;i++)
		dis[i]=2147483647;
	queue<int> q;
	q.push(s);
	dis[s]=0,vis[s]=1;
	while(!q.empty())
	{
		int t=q.front();
		q.pop(),vis[t]=0;
		for(int i=head[t];i;i=edge[i].nxt)
		{
			int to=edge[i].to;
			if(dis[to]>dis[t]+edge[i].dis)
			{
				dis[to]=dis[t]+edge[i].dis;
				if(!vis[to])
					q.push(to),vis[to]=1;
			}
		}
	}
}

 

 

(2)dfs版SPFA，可用来判断是否存在负环、正环，一般来说效率要比bfs版快(除非数据毒瘤)。

bool dfs_spfa(int u)
{
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].nxt)
    {
        if(dis[edge[i].to]>dis[u]+edge[i].dis)
        {
            dis[edge[i].to]=dis[u]+edge[i].dis;
            if(vis[edge[i].to]||dfs_spfa(edge[i].to))
                return 1;
        }
    }
    vis[u]=0;
    return 0;
}

spfa也可以用来求最长路。当然有正环的情况也是无解的。

例题：洛谷P1807

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define pr pair<double,int>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

const int maxn=1505;
const int maxm=5e4+5;

struct Edge
{
    int to,nxt,dis;
}edge[maxm];

int n,m,tot;
int head[maxn],dis[maxn],vis[maxn];

inline void addedge(int u,int v,int dis)
{
    edge[++tot].to=v,edge[tot].nxt=head[u],edge[tot].dis=dis,head[u]=tot;
}

void spfa()
{
    for(int i=1;i<=n;i++)
        dis[i]=-INF;
    dis[1]=0,vis[1]=1;
    queue<int> q;
    q.push(1);
    int u,v;
    while(!q.empty())
    {
        u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];i;i=edge[i].nxt)
        {
            v=edge[i].to;
            if(dis[v]<dis[u]+edge[i].dis)
            {
                dis[v]=dis[u]+edge[i].dis;
                if(!vis[v])
                    q.push(v),vis[v]=1;
            }
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    int u,v,d;
    while(m--)
    {
        scanf("%d%d%d",&u,&v,&d);
        addedge(u,v,d);
    }
    spfa();
    printf("%d\n",dis[n]==-INF?-1:dis[n]);
    return 0;
}

(3)贝尔曼·福特(Bellman-Ford)

(1)Dijkstra算法求的是正权图的单源最短路问题，对于权值有负数的情况就不能用Dijkstra求解了，因为如果图中存在负环，Dijkstra带优先队列优化的算法就会进入一个死循环，因为可以从起点走到负环处一直将权值变小 。对于带负权的图的最短路问题就需要用到Bellman-Ford算法了。

(2)Bellman-Ford算法可以在最短路存在的情况下求出最短路，并且在存在负权圈的情况下告诉你最短路不存在，前提是起点能够到达这个负权圈，因为即使图中有负权圈，但是起点到不了负权圈，最短路还是有可能存在的。它是基于这样一个事实：一个图的最短路如果存在，那么最短路中必定不存在圈，所以最短路的顶点数除了起点外最多只有n-1个。

代码：

#include<iostream>
#include<cstdio>
#define INF 0x3f3f3f3f
using namespace std;

struct edge
{
	int from,to,cost;
};

edge E[1005];
int d[1005];
int n,m;//顶点数 边数

void BellmanFord(int s)
{
	for(int i=0;i<n;i++)
		d[i]=INF;
        d[s]=0;
	while(true)
	{
		bool update=false;
		for(int i=0;i<m;i++)
		{
			edge e=E[i];
			if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost)
			{
				d[e.to]=d[e.from]+e.cost;
				update=true;
			}
		}
		if(!update)
			break;
	}
}

判负圈：(来自《挑战程序设计竞赛》)

(1)判断是否存在从s可达的负环：

bool find_negative_loop(int s)
{
    memset(d,INF,sizeof(d));
    d[s]=0;
    for(int i=0;i<n;i++)//最多执行n-1次
    {
        for(int j=0;j<m;j++)
        {
            edge e=E[j];
            if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost)
            {
                d[e.to]=d[e.from]+e.cost;
                if(i==n-1)//第n次仍然更新了 存在负圈
                    return 1;
            }
        }
    }
    return 0;
}

(2)判断所有的负环

bool find_negative_loop()
{
	memset(d,0,sizeof(d));
	for(int i=0;i<n;i++)//最多执行n-1次
	{
		for(int j=0;j<m;j++)
		{
			edge e=E[j];
			if(d[e.to]>d[e.from]+e.cost)
			{
				d[e.to]=d[e.from]+e.cost;
				if(i==n-1)//第n次仍然更新了 存在负圈
					return 1;
			}
		}
	}
	return 0;
}

多源最短路径：

求任意两对顶点之间的最短路径。

 弗洛伊德：(Floyd)

void floyd()
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                s[i][j]=min(s[i][j],s[i][k]+s[k][j]);
}

路径还原：

其实很简单：(1)迪杰斯特拉算法中更新最小值的时候令：path[i]=u，即记录最短路中i的前驱节点，因此最后得到的是从终点到起点的顺序。(2)弗洛伊德算法中更新最小值的时候令：path[i][j]=path[i][k]，即记录最短路中i的后继节点。

扩展一下：

其实dijkstra算法是可以解决多源多汇的问题的，给一张图，求集合A中的点到集合B中的点的距离的最小值，保证集合A、B没有相交的点。一般人可能第一想法就是暴力，对集合A(或集合B)中的每一个点都跑一次dijkstra，再取最小值就是答案。然而仔细思考我们可以得到更优的算法，我们可以建立一个超级源点S和一个超级汇点T，S到集合A中的每个点都有一条权值为0的有向边，集合B中的每一个点到T都有一条权值为0的有向边，以源点为起点跑dijkstra后计算出的到T的距离就是答案。进一步思考，这些我们加的边其实是没必要显示建立的，在此以堆优化的dijkstra算法为例，我们把集合A中的点(也就是与超级源点S相连的点)全部塞到堆中，同时在dis数组中把对应的值置为0，再新开一个数组标记集合B中的点(也就是与超级汇点相连的点)为true，那么在跑dijkstra算法的过程中，第一次访问到了标记为true的点，就得到了我们想要的答案。对于无向图来说，我们只需跑一次dijkstra，即集合A或集合B做起始点都可以；对于有向图来说，我们需要跑两次dijkstra，第一次A为源点B为汇点，第二次A为汇点B为源点。

板子就不挂了，贴一道例题，感兴趣的可以做一下。

HDU 6166