四种常用最短路径算法模板

最短路径算法中,有四种算法是最常见的,分别是Dijkstra算法,Floyd算法,Bellman-Ford算法和SPFA算法。

Dijkstra算法,求单源最短路径最稳定的一个算法,算法复杂度为O(n2),但可以通过队列优化。下面列出的模板是最原始的Dijkstra算法。以需要求的源为中心,向四周扩散,第一次求出的是与源直接相连接的点的距离。求出这些距离中的最短距离,然后通过这个点将与它相连接的点的最短距离更新,然后再求出现在的最短距离,如此这样下去,直到所有的点都已经被遍历过为止。已经求出最短距离的点不在参与更新。具体模板如下(以POJ3268为例):

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define INF 0x7ffffff
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
#define out(v) cerr << #v << ": " << (v) << endl
#define SZ(v) ((int)(v).size())
const int maxint = -1u>>1;20 int n,m,x;
const int maxn = 1111;
int dist[maxn];
int dist2[maxn];
int d[maxn][maxn];
bool flag[maxn];

void Dijkstra(int x)
{
    memset(flag,false,sizeof(flag));
    for(int i=1;i<=n;++i)
    {
        dist[i] = d[x][i];
    }
    flag[x] = true;
    dist[x] = 0;
    
    for(int i=2;i<=n;++i)
    {
        //寻找没有标记而且dist值最小的点
        int u = 1;
        int mindis = maxint;
        for(int j=1;j<=n;++j)
        {
            if(!flag[j] && dist[j] < mindis)
            {
                mindis = dist[j];
                u = j;
            }
        }
        flag[u] = true;
        for(int j=1;j<=n;++j)
        {
            if(!flag[j] && d[u][j] < maxint)
            {
                dist[j] = min(dist[j],dist[u] + d[u][j]);
            }
        }
    }
}


int main()
{
    while(scanf("%d%d%d",&n,&m,&x) != EOF)
    {
        int a,b,len;
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                d[i][j] = maxint;
            }
        }
        for(int i=1;i<=m;++i)
        {
            scanf("%d%d%d",&a,&b,&len);
            d[a][b] = len;
        }
        Dijkstra(x);
        for(int i=1;i<=n;++i) dist2[i] = dist[i];
        for(int i=1;i<=n;++i)
        {
            for(int j=i+1;j<=n;++j)
            {
                swap(d[i][j],d[j][i]);
            }
        }
        Dijkstra(x);
        int ans = 0;
        for(int i=1;i<=n;++i)
        {
            ans = max(ans,dist[i] + dist2[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

Floyd算法其实是Floyd-Warshall算法的简称。分以下两步进行。

1,从任意一条单边路径开始。所有两点之间的距离是边的权,如果两点之间没有边相连,则权为无穷大。
2,对于每一对顶点 u 和 v,看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。
Floyd算法是一种动态规划算法,稠密图效果最佳,边权可正可负。此算法简单有效,由于三重循环结构紧凑,对于稠密图,效率要高于执行|V|次Dijkstra算法。
具体模板如下所示(以POJ2240为例):

/*
 * Author: xiagenyuan
 * Created Time:  2013/5/1 21:03:44
 * File Name: D:\ACMICPC\20130501\POJ2240.cpp
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
const int maxint = -1u>>1;
const int maxn = 33;
int n,m;
map mp;//用来为名字是字符串的点对应数字
double ra[maxn][maxn]; //存取两点间的的路径

void Floyd()//对临接表进行Floyd处理
{
    for(int k=1;k<=n;++k)
    {
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                if(ra[i][j] < ra[i][k]*ra[k][j])
                {
                    ra[i][j] = ra[i][k]*ra[k][j];
                }
            }
        }
    }
}

int main()
{
    int cas = 1;
    while(scanf("%d",&n) != EOF && n)
    {
        mp.clear();
        string name;
        for(int i=1;i<=n;++i)
        {
            cin>>name;
            mp[name]=i;
        }
        scanf("%d",&m);
        string name1,name2;
        double rate;
        memset(ra,1,sizeof(ra));
        for(int i=1;i<=m;++i)
        {
            cin>>name1>>rate>>name2;
            ra[mp[name1]][mp[name2]]= rate;
        }
        Floyd();
        bool flag = false;
        for(int i=1;i<=n;++i)
        {
            if(ra[i][i] > 1) 
            {
                flag = true;
                break;
            }
        }
        if(flag) printf("Case %d: Yes\n",cas);
        else printf("Case %d: No\n",cas);
        cas++;
    }
    return 0;
}

Bellman-Ford算法

1、以下操作循环执行至多n-1次,n为顶点数:
2、对于每一条边e(u, v),如果Distant[u] + w(u, v) < Distant[v],则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值;
    若上述操作没有对Distant进行更新,说明最短路径已经查找完毕,或者部分点不可达,跳出循环。否则执行下次循环;

3、为了检测图中是否存在负环路,即权值之和小于0的环路。对于每一条边e(u, v),如果存在Distant[u] + w(u, v) < Distant[v]的边,则图中存在负环路,即是说改图无法求出单源最短路径。否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。

具体模板如下所示:

/*
 * Author: xiagenyuan
 * Created Time:  2013/5/1 21:39:36
 * File Name: C:\Users\Genyuan\Desktop\图论系列模板\Bellman-Ford.cpp
 */
//模板未进行验证
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
const int maxint = 9999999;
const int maxnum = 100;
struct edge
{
    int u,v;//每条边的起点和终点
    int weight;//边的权值
};
edge e[maxnum];//保存所有边的值
int dist[maxnum]; //保存节点到源点的最短距离
int n,m,x; //节点数量,边的数量,源点

//读入数据,初始化图
void init()
{
    while(scanf("%d%d%d",&n,&m,&x) != EOF)
    {
        for(int i=1;i<=n;++i) dist[i] = maxint;
        dist[x] = 0;
        for(int i=1;i dist[e[i].u]+e[i].weight)
        {
            flag = false;
            break;
        }
    }
    return flag;
}

int main()
{
    init();
    if(BellmanFord())
    {
        for(int i=1;i<=m;++i) cout<

SPFA算法其实就是Bellman-Ford算法,只是它用队列进行了优化。用队列进行优化有三种形式:

1、简单地用队列进行存储。

2、SLF:Small Label First 策略,设要加入的节点是j,队首元素为i,若dist(j)

3、LLL:Large Label Last 策略,设队首元素为i,队列中所有dist值的平均值为x,若dist(i)>x则将i插入到队尾,查找下一元素,直到找到某一i使得dist(i)<=x,则将i    

    出对进行松弛操作。

以下模板是针对第一种情况(POJ3268为例):

/*
 * Author: xiagenyuan
 * Created Time:  2013/5/1 22:26:23
 * File Name: D:\ACMICPC\20130501\POJ3268SPFA.cpp
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define eps 1e-8
#define sgn(a) (a>eps)-(a<-eps)
#define LL long long
const int maxint = 99999999;
const int maxn = 1000 + 111;
int n,m,x;
int d[maxn][maxn];
int dist[maxn];
int dist2[maxn];
bool visited[maxn];
int que[2*maxn];

void spfa()
{
    int pri = 0,end = 1;
    memset(visited,false,sizeof(visited));
    visited[x] = true;
    for(int i=1;i<=n;++i) dist[i] = maxint;
    dist[x] = 0;
    que[0] = x;
    while(pri < end)
    {
        int index = que[pri];
        for(int i=1;i<=n;++i)
        {
            if(dist[index] + d[index][i] < dist[i])
            {
                dist[i] = dist[index] + d[index][i];
                if(!visited[i])
                {
                    que[end++] = i;
                    visited[i] = true;
                }
            }
        }
        visited[index] = false;
        pri++;
    }    
}

int main()
{
    while(scanf("%d%d%d",&n,&m,&x) != EOF)
    {
        int a,b,len;
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                d[i][j] = maxint;
            }
        }
        for(int i=1;i<=m;++i)
        {
            scanf("%d%d%d",&a,&b,&len);
            d[a][b] = len;
        }
        spfa();
        for(int i=1;i<=n;++i) dist2[i]  = dist[i];
        for(int i=1;i<=n;++i)
        {
            for(int j=i+1;j<=n;++j)
            {
                swap(d[i][j],d[j][i]);
            }
        }
        spfa();
        int ans = 0;
        for(int i=1;i<=n;++i)
        {
            ans = max(ans,dist[i] + dist2[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}




你可能感兴趣的:(算法相关,最短路径)