图论篇3——最短路径 Dijkstra算法、Floyd算法

最短路径

问题背景:地图上有很多个城市,已知各城市之间距离(或者是所需时间,后面都用距离了),一般问题无外乎就是以下几个:

  • 从某城市到其余所有城市的最短距离【单源最短路径】
  • 所有城市之间相互的最短距离【任意两点最短路径】
  • 各城市距离一致,给出需要最少中转方案 【最少中转】

深度优先搜索

适用范围:啥都不适用,只能处理n<10的情况

深搜求最短路径的思想和用深搜迷宫寻路有一点像,找出所有的从起点目标点的路径,选出其中最短的一条。

此算法仅供娱乐参考,实际不会用它的,因为算法复杂度是$O(n!)$

深度优先搜索:

const int inf = 1 << 30;

int M[50][50];
bool fuck[50];
int n, res;

//cur-当前所在城市编号,dis-当前已走过的路径
void dfs(int cur, int dis) {
    //若当前的路径值已比之前找到的最短路大,没必要继续往下搜索了,其实没什么必要,深搜本来就属于暴力算法,这个小优化属于杯水车薪
    if (dis > res) 
        return; 
    //当前已到达目的城市,更新min
    if (cur == n) { 
        res = min(res, dis);
        return;
    }

    //对1~n号城市依次尝试
    for (int i = 1; i <= n; i++) { 
        //若cur与i之间有路,且i没有在已走过的路径中
        if (M[cur][i] != inf && !fuck[i]) { 
            fuck[i] = true; //标记i为已走的路径
            dfs(i, dis + M[cur][i]); //继续搜索
            fuck[i] = false; //回溯
        }
    }
}
#include <iostream>
#include <algorithm>
#include <fstream>
#include <cstdio>
#include <queue>

using namespace std;
const int inf = 1 << 30;

int M[50][50];
int path[50];
bool fuck[1000];
int n, m, res = inf, cnt;

//cur-当前所在城市编号,dis-当前已走过的路径
void dfs(int cur, int dis,int destination,int k) {
    //若当前的路径值已比之前找到的最短路大,没必要继续往下搜索了,其实没什么必要,深搜本来就属于暴力算法,这个小优化属于杯水车薪
    //if (dis > res) 
    //    return; 
    //当前已到达目的城市,更新min
    if (cur == destination) {
        res = min(res, dis);
        //cnt++;
        for (int i = 0; i < k; i++) {
            cout << path[i] << ' ';
        }
        cout << endl;
        return;
    }
    
    //对1~n号城市依次尝试
    for (int i = 1; i <= n; i++) { 
        //若cur与i之间有路,且i没有在已走过的路径中
        if (M[cur][i] != 0 && M[cur][i] != inf && !fuck[i]) {
            fuck[i] = true; //标记i为已走的路径
            path[k] = i;
            dfs(i, dis + M[cur][i], destination, k + 1); //继续搜索
            fuck[i] = false; //回溯
        }
    }
}

int main() {
#ifdef LOCAL
    fstream cin("data.in");
#endif // LOCAL
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i != j)
                M[i][j] = inf;
        }
    }
    
    for (int i = 0; i < m; i++) {
        int c1, c2, c3;
        cin >> c1 >> c2 >> c3;
        M[c1][c2] = c3;
        M[c2][c1] = c3;
    }
    cnt = 0;
    res = inf;
    fuck[1] = true;
    path[0] = 1;
    dfs(1, 0, 4, 1);
    
    return 0;
}
完整测试代码

宽度优先搜索

适用范围:最少中转方案,处理n的级别看脸

假如现在是最少中转方案问题(或者所有边的权值一致) ,问从城市1到城市4需要经过的最少中转城市个数。

这类问题和宽搜求迷宫的最短路径思想完全一样,从开始点逐层扩展,找到目标停止。

宽搜的算法复杂度也是$O(n!)$,不过看脸,如果在前面几层就找到目标了,就比较快。

也就是目标点需要中转几次,如果一次都不要中转,那么第二层就能搜索到;如果需要中转n-2次,那就得搜索到最后一层,就也是$O(n!)$了

宽度优先搜索:

int M[50][50];
int path[50];
bool fuck[1000];
int n, m, res = inf, cnt;

int bfs(int start, int destination){
    queue<pair<int, int>> q; //城市编号、当前是第几座城市
    q.push({ start,0 }); //把起始点加入队列
    fuck[start] = true; //标记为已在路径中
    while (!q.empty()){
        int cur = q.front().first, dis = q.front().second;
        q.pop();
        for (int i = 1; i <= n; i++) {
            //如果当前点到i点有路,并且当前还没有加入队列中
            if (M[cur][i] != inf && !fuck[i]) {
                    q.push({ i,dis + 1 });
                    fuck[i] = true;
                    if (i == destination) //如果发现了目标点
                        return dis;//这里具体是算多少步看题目咋问了
            }
        }
    }
}
#include <iostream>
#include <algorithm>
#include <fstream>
#include <cstdio>
#include <queue>

using namespace std;
const int inf = 1 << 30;

int M[50][50];
int path[50];
bool fuck[1000];
int n, m, res = inf, cnt;

int bfs(int start, int destination){
    queue<pair<int, int>> q; //城市编号、当前是第几座城市
    q.push({ start,0 }); //把起始点加入队列
    fuck[start] = true; //标记为已在路径中
    while (!q.empty()){
        int cur = q.front().first, dis = q.front().second;
        q.pop();
        for (int i = 1; i <= n; i++) {
            //如果当前点到i点有路,并且当前还没有加入队列中
            if (M[cur][i] != inf&& !fuck[i]) {
                    q.push({ i,dis + 1 });
                    fuck[i] = true;
                    if (i == destination) //如果发现了目标点
                        return dis;//这里具体是算多少步看题目咋问了
            }
        }
    }
}

int main() {
#ifdef LOCAL
    fstream cin("data.in");
#endif // LOCAL
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i != j)
                M[i][j] = inf;
        }
    }
    
    for (int i = 0; i < m; i++) {
        int c1, c2, c3;
        cin >> c1 >> c2 >> c3;
        M[c1][c2] = c3;
        M[c2][c1] = c3;
    }
    
    cout << bfs(1, 4);
    
    return 0;
}
完整测试代码

这两个算法我觉得算是迷宫寻路算法的延伸,可以看下迷宫寻路问题全解,用在求最短路径中的话,效率太低,无法解决实际问题。

接下来才是重点。

迪杰斯特拉(Dijkstra)算法

适用范围:不含负权边的单源最短路径、最少中转

不含负权边就是所有路径长度大于0,牵扯到负权边,请参考 Bellman-Ford算法

思路图解

维护一个$dis$数组记录起点(按题目要求来,这里取$1$) 到达的所有节点的距离。(规定到自己的路径长度0,到不了的点是 inf(极大值))

找出当前距离$1$最近的结点:$4$。(已经访问过的,我们标记为红色,不再次访问)

 

借助$4$节点,对$dis$数组进行更新(就是如果结点$1$借助结点$4$到别的结点有更短的路径,就对$dis$数组进行值替换)

找出当前距离$1$最近的结点:$2$。

走到$2$,无法更新$dis$数组,无操作。

找出当前距离$1$最近的结点:$3$。

借助$3$节点,对$dis$数组进行更新,最后走到$5$节点,退出。(实际过程中,走到最后一个节点,别的节点都访问过,进行标记了,什么也不会做)。

这个时候$dis$数组就是从起点$1$到所有节点的最短路径了,如果还有$inf$表示不是连通图。

 

简单版(邻接矩阵+优先级队列):

测试题目:http://acm.hdu.edu.cn/showproblem.php?pid=2544 (数据很弱,建议再做后面一题)

#include <fstream>
#include <iostream>
#include <queue>
#include <algorithm>
#include <string.h>
using namespace std;

const int inf = 1 << 30;
int n, m;
bool book[1001];
int M[1001][1001];
int dis[1001];

class P {
public:
    int to, dis;
    P(int t, int d) :to(t), dis(d) {}
    
    bool operator< (P a) const {
        return a.dis < dis;
    }
};

priority_queue<P>q;
void initialize() {
    fill(book, book + n + 1, false);
    fill(dis, dis + n + 1, inf);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i != j)M[i][j] = inf;
        }
    }
}
void dijkstra() {
    dis[1] = 0;
    q.push({ 1, 0 });
    while (!q.empty()) {
        int v = q.top().to; q.pop();
        if (book[v])continue;
        book[v] = true;
        for (int i = 1; i <= n; i++) {
            if (!book[i] && dis[i] > dis[v] + M[v][i]) {
                dis[i] = dis[v] + M[v][i];
                q.push({ i, dis[i] });
            }
        }
    }
}

int main() {
#ifdef LOCAL
    fstream cin("data.in");
#endif // LOCAL
    while (cin >> n >> m) {
        if (n == 0 && m == 0)break;
        initialize();
        for (int i = 0; i < m; i++) {
            int A, B, C;
            cin >> A >> B >> C;
            M[A][B] = C;
            M[B][A] = C;
        }
        dijkstra();
        cout << dis[n] << endl;
    }
    return 0;
}
View Code

正式版(邻接表+优先级队列)

测试题目:https://www.luogu.org/problemnew/show/P4779

#include <fstream>
#include <iostream>
#include <stdio.h>
#include <queue>
using namespace std;
int dis[100001];
bool fuck[100001];
const int inf = 1 << 30;
int n, m, s;
struct ENode {
    int to, dis;
    ENode* next = NULL;
    ENode() {}
    ENode(int t, int d) :to(t), dis(d) {}
    void push(int t, int d) {
        ENode* p = new ENode(t, d);
        p->next = next;
        next = p;
    }

    bool operator<(ENode e)const {
        return e.dis < dis;
    }
}head[100005];

void dijkstra() {
    priority_queue<ENode>q;
    fill(dis, dis + n + 1, inf);
    dis[s] = 0;
    q.push(ENode(s, 0));
    while (!q.empty()) {
        //获得当期距离 源点 最近的点
        int v = q.top().to, d = q.top().dis; q.pop();
        if (fuck[v])continue;
        fuck[v] = true;
        ENode* p = head[v].next;
        while (p) {
            int to = p->to;
            if (!fuck[to] && dis[to] > d + p->dis) {
                dis[to] = d + p->dis;
                q.push(ENode(to, dis[to]));
            }
            p = p->next;
        }
    }

}

int main() {
#ifdef LOCAL
    fstream cin("data.in");
#endif // LOCAL
    int c1, c2, c3;
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++) {
        //cin >> c1 >> c2 >> c3;
        scanf("%d%d%d", &c1, &c2, &c3);
        head[c1].push(c2, c3);
    }    
    dijkstra();
    for (int i = 1; i <= n; i++) {
        printf("%d ", dis[i]);
    }
    cout << endl;
    return 0;
}
View Code

提一句如果是要求找最少中转方案,那么就把每个边的权值都设为1,在求最短路径即可。

时间复杂度分析

一般默认迪杰斯特拉算法复杂度为$O(n^2)$,也就是每次从$dis$中获取路径最短的结点,需要花费线性的时间$O(n)$,但这是普通情况下。【$n$为顶点数】使用优先级队列后,从$dis$中获取路径最短的结点只需要$O(logn)$(因为我们用了一个标记数组,所以堆中的数据个数不可能会超过$n$,所以是$O(logn)$,如果没有加这个复杂度是$O(logm)$,m为边的个数)。所以,堆优化的迪杰斯特拉算法时间复杂度为$O((m+n)logn)$。

关于负权边

$Dijkstra$是一种基于贪心策略的算法。每次新扩展一个路径最短的点,更新与它相邻的所有点。当所有边权为正时,由于不会存在一个路程更短的没扩展过的点,所以这个点的路程就确定下来了,这保证了算法的正确性。但也正因为这样,这个算法不能处理负权边,因为扩展到负权边的时候,某个点会产生更短的路径,但可能该点已被标记。

比如这张图,按照Dijkstra算法,假如起点是A,一定会先找到C,并且认为已经找到A到C最短路径,在没有负边的时候是这样的,但现在B到C是-2,这就出现错误了。

Floyd算法

Floyd算法属于动态规划,实现容易,好理解,但缺点就是时间复杂度高是$O(n^3)$。

$M [ j ] [ k ]$ 表示从$ j$ 到 $k$ 的路径,而 $i$ 表示当前 $j$ 到 $k$ 可以借助的点;红色部分表示,如果 $j$ 到 $i$ ,$i$ 到 $k$ 是通的,就将 $j$ 到 $k$ 的值更新为$min(M[j][i] + M[i][k],M[j][k] )$

for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        for (int k = 1; k <= n; k++) {
            if (j != k && M[j][i] != inf && M[i][k] != inf)
                M[j][k] = min(M[j][i] + M[i][k], M[j][k]);
        }
    }
}

给个题目链接,可以交试一下:http://www.dotcpp.com/oj/problem1709.html

#include <iostream>
#include <queue>
using namespace std;


#define inf 2147483647
int M[1000][1000];


int main() {
    int n;
    queue<int>q;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> M[i][j];
            if (M[i][j] == 0 && i != j)M[i][j] = inf;
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            for (int k = 1; k <= n; k++) {
                if (M[j][k] != 0) {
                    if (M[j][i] != inf && M[i][k] != inf) {
                        M[j][k] = M[j][i] + M[i][k] < M[j][k] ? M[j][i] + M[i][k] : M[j][k];
                    }
                }
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (M[i][j] == inf)cout << -1 << " ";
            else
            cout << M[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}
完整代码

Dijkstra & Floyd 对比

$Dijkstra$算法的复杂度为$O(n^2)$【不考虑堆优化的情况】,如果采用Dijkstra算法来计算图中任两点之间的最短距离,复杂度也为$O(n^3)$,虽然复杂度相同,但是看代码,两个算法运算量差了很多,也就是$Dijkstra$算法输在了常数项。但是堆优化后的$Dijkstra$算法,还是要完全优于$Floyd$算法的。

对比:

 

posted @ 2019-10-26 16:55  qmyc1999  阅读(...)  评论(...编辑  收藏