求最短路的三种方法:dijkstra,spfa,floyd

2018-06-17 22:29:49来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

dijkstra是一种单源最短路算法。在没有负权值的图上,vi..vj..vk是vi到vk最短路的话,一定要走vi到vj的最短路。所以每次取出到起点距离最小的点,从该点出发更新邻接的点的距离,如果更新成功则把新点加入priority_queue。储存图使用的是邻接表。代码如下:

#include <bits/stdc++.h>//有向图
using namespace std;
//dijkstra 不适用于带负权的图
const int maxn = 1007, maxm = 20007, INF = 0x3f3f3f;// maxn比顶点数略大,maxm比边数略大
int head[maxn], vis[maxn], dis[maxn], fa[maxn];
int next[maxm], u[maxm], v[maxm], w[maxm];
typedef pair<int, int> pi;// pair排序策略是优先排前面,pair把距离放前面,点放后面
int n, m;
void ini()
{
    memset(vis, 0, sizeof(vis));//开始所有点都没被处理
    memset(head, -1, sizeof(head));//所有点都没有边
    for(int i = 0; i <= n; i++)
        dis[i] = INF;//起点到所有点距离为无穷大
}

void dij(int s, int e)
{
    priority_queue<pi, vector<int>, greater<int> > Q;//优先队列
    dis[s] = 0;
    Q.push(make_pair(dis[s], s));
    while(!Q.empty())
    {
        pi u = Q.top();
        Q.pop();//取出d最小的点
        int x = u.second;
        if(x == e)
            break;
        if(vis[x])//处理过,跳过
            continue;
        vis[x] = 1;
        for(int i = head[x]; ~i; i = next[i])//更新从当前d最小的点相邻点的距离
        {
            if(dis[v[i]] > dis[x] + w[i])
            {
                dis[v[i]] = dis[x] + w[i];//松弛成功
                fa[v[i]] = x;
                Q.push(make_pair(dis[v[i]], v[i]));//把更新成功的点加入队列
            }
        }
    }
    if(dis[e] == INF)
        return;//s到e无路径
    vector<int> ans;//用vector从终点往起点找路径,也可以用递归
    int temp = e;
    while(temp!=s)
    {
        ans.push_back(temp);
        temp = fa[temp];
    }
    ans.push_back(s);
    for(int i = ans.size()-1; i >= 0; i--)
        printf("%d ", ans[i]);
    printf("\n%d\n", dis[e]);
}

int main()
{
    //freopen("in.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        ini();
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d", u+i, v+i, w+i);
            next[i] = head[u[i]];
            head[u[i]] = i;//建立邻接表
        }
        int S, E;//起点终点
        scanf("%d%d", &S, &E);
        dij(S, E);
    }
    return 0;
}

dijkstra经典的一比,不过要求不能含负权,于是又学了下能处理带负权图的spfa:

spfa感觉有点像bfs,但bfs只处理一个节点一次,而spfa如果松弛了路径上经过的节点,就要对路径上之后的点都更新一遍。有负环的话,每走一遍负环,距离就减小环长,也就不存在最短路,所以假定不存在负环(或者判断一下有无负环)。代码如下:

#include <bits/stdc++.h>//有向图
using namespace std;
const int maxn = 1007, maxm = 10007, INF = 0x3f3f3f3f;
int head[maxn], in[maxn], dis[maxn], fa[maxn];//in标记在queue中的点
int u[maxm], v[maxm], w[maxm], next[maxm];
int n, m;

void ini()
{
    memset(in, 0, sizeof(in));
    memset(head, -1, sizeof(head));
    for(int i = 0; i <= n; i++)
        dis[i] = INF;
}

void print(int s, int e)//递归打印路径
{
    if(e!=s)
        print(s, fa[e]);
    printf("%d ", e);
}

void spfa(int s, int e)//有点像bfs,不过bfs不会处理之前处理过的点
{
    queue<int> Q;
    dis[s] = 0;
    in[s] = 1;
    Q.push(s);
    while(!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        in[x] = 0;
        for(int i = head[x]; ~i; i = next[i])
        {
            if(dis[v[i]] > dis[x] + w[i])
            {
                dis[v[i]] = dis[x] + w[i];
                fa[v[i]] = x;
                if(!in[v[i]])
                   {
                       Q.push(v[i]);
                       in[v[i]] = 1;
                   }
            }
        }
    }
    print(s, e);
    printf("\n%d\n", dis[e]);
}
int main()
{
    freopen("in.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        ini();
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d", u+i, v+i, w+i);
            next[i] = head[u[i]];
            head[u[i]] = i;
        }
        int s, e;
        scanf("%d%d", &s, &e);
        spfa(s, e);
    }
    return 0;
}

多源最短路径有个floyd算法,其实就是离散讲的warshall闭包:(但是因为时间复杂度O(n^3)有点嫌弃2333),没自己实现一下,核心代码如下:

    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(g[i][j] > g[i][k] + g[k][j])
                    g[i][j] = g[i][k] + g[k][j];

思路是开始用邻接矩阵存放图,更新两点距离只能靠经过其他点中转,所以每次多允许经过一个点(即第一个循环),考虑最短路(第二三重循环)。

floyd好处是代码短,能一次求出所有节点之间的最短路。

 

今天收获挺大,总结一下稠密/无负权图用dijkstra,稀疏/有负权图用spfa,时间要求不高用floyd。

 

 

 

(心情依然很烂)

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:一些有用的小技巧/小公式/玄学优化(雾

下一篇:P1880 石子合并