搜索与图论---最短路

Next---YOLO

已于 2023-01-03 22:34:10 修改

阅读量983

点赞数

分类专栏： # 算法基础文章标签：图论算法

于 2022-12-23 22:49:44 首次发布

本文链接：https://blog.csdn.net/m0_51366201/article/details/128419256

版权

算法基础专栏收录该内容

20 篇文章 2 订阅

订阅专栏

本文详细介绍了单源最短路问题的解决算法，包括Dijkstra和Bellman-Ford算法，以及它们在正权边和负权边情况下的应用。同时，讲解了多源汇最短路的Floyd算法，用于处理起点和终点不确定的情况。这些算法在图论和路径搜索问题中有着广泛的应用。

摘要由CSDN通过智能技术生成

文章目录

- - 最短路:建图！

最短路:建图！

源点—起点
汇点—终点
约定n为点数，m为边数

1单源最短路：求一个点到其他所有点的最短路

1.1所有边权都是正数

(1)朴素的Dijkstra算法（On^2）

在这里插入图片描述
例题：Dijkstra求最短路 I

代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 510;

int n,m;
int g[N][N];//邻接矩阵
int dist[N];//用于存储每个点到起点的最短距离
bool st[N];//xx点的最短距离已经确定了

int dijkstra()
{
    //先把所有距离初始化为正无穷
    memset(dist,0x3f,sizeof dist);//dist 数组的各个元素为无穷大
    dist[1] = 0;//源点到源点的距离为置为 0,1号点
    //迭代n次，每次可以确定一个点到起点的最短路
    for(int i = 0;i < n;i++)
    {
        int t = -1;
        //t的作用？
        /*一开始t的赋值是-1
        如果t没有被更新，
        那么要更新一下t*/
        
        //遍历所有点
        for(int j = 1;j <= n;j++)//遍历 dist 数组，找到没有确定最短路径的节点中距离源点最近的点t
             //不在s集合，并且
            //如果没有更新过，则进行更新， 或者发现更短的路径，则进行更新
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
         //加入到s集合中
        st[t] = true;
        //找到了距离最小的点t，并用最小的点t去更新其他的点到起点的距离
        for(int j = 1;j <= n;j++)//遍历 t 所有可以到达的节点 i
            dist[j] = min(dist[j],dist[t] + g[t][j]);//更新 dist[j]
    }
    
    if(dist[n] == 0x3f3f3f3f) return -1;
    //memset 按字节赋值，所以memset 0x3f 就等价与赋值为0x3f3f3f3f
    return dist[n];
}

int main()
{
    scanf("%d %d",&n,&m);
    
    //初始化邻接矩阵
    /*for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
            if(i == j)  g[i][j] = 0;
            else g[i][j] = INF;
    */
    memset(g,0x3f,sizeof g);
    
    //读入边
    while(m--)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        g[a][b] = min(g[a][b],c);//可能有重边，保留长度最短的边
    }
    
    int t = dijkstra();
    
    printf("%d\n",t);
    
    return 0;
}

（2）堆优化版的Dijkstra算法（Omlogn）

用堆对朴素版进行优化

例题：Dijkstra求最短路 II
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 1e6 + 10;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    cout << dijkstra() << endl;

    return 0;
}

1.1存在负权边

（1）Bellman–Ford O（nm）

Bellman - ford 算法是求含负权图的单源最短路径的一种算法，效率较低，代码难度较小。其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
(通俗的来讲就是：假设 1 号点到 n 号点是可达的，每一个点同时向指向的方向出发，更新相邻的点的最短距离，通过循环 n-1 次操作，若图中不存在负环，则 1 号点一定会到达 n 号点，若图中存在负环，则在 n-1 次松弛后一定还会更新)

注意：back[] 数组是上一次迭代后 dist[] 数组的备份，由于是每个点同时向外出发，因此需要对 dist[] 数组进行备份，若不进行备份会因此发生串联效应，影响到下一个点

注：不存在负权回路
在这里插入图片描述
例题：有边数限制的最短路

在下面代码中，是否能到达n号点的判断中需要进行if(dist[n] > INF/2)判断，而并非是if(dist[n] == INF)判断，原因是INF是一个确定的值，并非真正的无穷大，会随着其他数值而受到影响，dist[n]大于某个与INF相同数量级的数即可

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 510, M = 10010;

struct Edge
{
    int a, b, w;
}edges[M];

int n, m, k;
int dist[N], backup[N];

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < k; i ++)
    {
        memcpy(backup, dist, sizeof dist);
        for (int j = 0; j < m; j ++)
        {
            auto v = edges[j];
            dist[v.b] = min(dist[v.b], backup[v.a] + v.w);
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);

    for (int i = 0; i < m; i ++)
    {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
    }

    bellman_ford();

    if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else printf("%d\n", dist[n]);

    return 0;
}

（2）SPFA 一般：O（m），最坏O（nm）

其实是对Bellman–Ford做了优化
在这里插入图片描述
基本思路：更新过谁，我就拿谁来更新别人

例题：spfa求最短路
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 1e6 + 10;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return dist[n];


}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    
    int t = spfa();
     if (t == 0x3f3f3f3f) puts("impossible");
    else printf("%d\n", t);

    return 0;
}

例题：spfa判断负环

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 1e6 + 10;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N],cnt[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

bool spfa()
{
   

    queue<int> q;
   //把所有点全部放入
   for(int i = 1;i <= n;i++)    
   {
       st[i] = true;
       q.push(i);
   }

    while (q.size())
    {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                
                if(cnt[t] > n)  return true;
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;


}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    
    if(spfa())  puts("Yes");
    else puts("No");

    return 0;
}

2.多源汇最短路：起点和终点不确定

Flod算法 O（n^3）

在这里插入图片描述
初始为邻接矩阵，结束后为从i到j的最短路。
例题：Floyd求最短路

floyd本身是个动态规划算法，在代码实现的时候省去了一维状态。
原状态是：f[i, j, k]表示从i走到j的路径上除了i, j以外不包含点k的所有路径的最短距离。那么f[i, j, k] = min(f[i, j, k - 1), f[i, k, k - 1] + f[k, j, k - 1]。
因此在计算第k层的f[i, j]的时候必须先将第k - 1层的所有状态计算出来，所以需要把k放在最外层。

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 210, INF = 1e9;

int n, m, Q;
int d[N][N];

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

int main()
{
    scanf("%d%d%d", &n, &m, &Q);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = min(d[a][b], c);
    }

    floyd();

    while (Q -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);

        int t = d[a][b];
        if (t > INF / 2) puts("impossible");
        else printf("%d\n", t);
    }

    return 0;
}