搜索与图论（二）：最短路径(没有负环)

最新推荐文章于 2022-04-12 23:16:58 发布

稻城亚丁

最新推荐文章于 2022-04-12 23:16:58 发布

阅读量400

点赞数 1

分类专栏：算法基础文章标签：算法数据结构图论堆栈

本文链接：https://blog.youkuaiyun.com/weixin_44798365/article/details/121642700

版权

算法基础专栏收录该内容

25 篇文章

订阅专栏

n为图点的数量，m为图边的数量

最短路：单源最短路、多源最短路

单源最短路：

多源最短路：Floyd算法 O（n^3）

朴素Dijkstra算法（稠密图）

例题：

Dijkstra求最短路 I

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1

数据范围

1≤n≤500
1≤m≤105
图中涉及边长均不超过10000。

输入样例：

输出样例：

解题思路：

解题代码：

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

using namespace std;

const int N=510;

int n,m;
int g[N][N];
int dist[N];//从1号点走到每个点的当前的最小距离是多少
bool st[N];//每个点的最小路径是否已经确定

int dijkstra()
{
    memset(dist,0x3f,sizeof dist);//初始化距离
    dist[1]=0;
    
    for(int i=0;i<n;i++)//迭代n次
    {
        //每次先找到当前没有确定最短路长度的点当中距离最小的那个
        int t=-1;//表示还没有确定
        for(int j=1;j<=n;j++)//遍历所有点
            if(!st[j]&&(t==-1||dist[t]>dist[j]))//还没有确定最短路并且等于-1或者当前路径不是最短的
                t=j;

        if(t==n) break;       
        st[t]=true;//将t加入到集合里面去
        
        for(int j=1;j<=n;j++)//用t来更新其他点的距离
            dist[j]=min(dist[j],dist[t]+g[t][j]);//用1到t，t到j的长度来更新1到j的长度
    }
    
    if(dist[n] ==0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d",&n,&m);
    
    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);//a,b之间可能存在多条边，保留短的边
    }
    
    int t=dijkstra();
    
    printf("%d\n",t);
    
    return 0;
}

堆优化Dijkstra算法（稀疏图）

例题：

Dijkstra求最短路 II

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1

1≤n,m≤1.5×105
图中涉及边长均不小于 0，且不超过 10000

输入样例：

输出样例：

解题代码：

#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;//因为是稀疏图，改成邻接表的形式，w表权重
int dist[N];//从1号点走到每个点的当前的最小距离是多少
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});//将一号点放进来，来更新其它所有点，距离是0 ，编号是1
    
    while(heap.size())//堆里不为空
    {
        //每次找到当前距离最小的点
        auto t = heap.top();//堆的起点
        heap.pop();
        
        int ver = t.second, distance = t.first;//点的标号，点的距离
        //如果说ver这个点之前已经出现过了，说明这个点是个冗余备份，就没有必要再处理它了
        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])//当前的距离大于从t过来的距离就更新
           {
            
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], 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);//读入m条边
    }
    
    cout << dijkstra() << endl;

    return 0;
}

Bellman-Ford算法

例题：

有边数限制的最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k

接下来 m行，每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围

1≤n,k≤500
1≤m≤10000
任意边长的绝对值不超过 10000

输入样例：

输出样例：

解题代码：

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

using namespace std;

const int N=510,M=10010;

int n,m,k;
int dist[N],backup[N];//距离，

struct Edge//存所有边
{
    int a,b,w;//a是起点，b是终点，w是权重
    
}edges[M];

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++)//遍历所有边
        {
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b]=min(dist[b],backup[a]+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;
}

SPFA算法

只有“我”变小了，我后面的才会变小。

网格图容易“卡”SPFA算法

例题：

spfa求最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 impossible。

数据范围

1≤n,m≤105
图中涉及边长绝对值均不超过 10000

输入样例：

输出样例：

解题代码：

#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;//因为是稀疏图，改成邻接表的形式，w表权重
int dist[N];//从1号点走到每个点的当前的最小距离是多少
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);//读入m条边
    }
    
   int t=spfa();
   
   if(t==0x3f3f3f3f) puts("impossible");
   else printf("%d\n",t);
   

    return 0;
}

spfa判断负环

例题：spfa判断负环

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你判断图中是否存在负权回路。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

如果图中存在负权回路，则输出 Yes，否则输出 No。

数据范围

1≤n≤2000
1≤m≤10000
图中涉及边长绝对值均不超过 10000

输入样例：

输出样例：

Yes

解题代码：

#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;//w表权重
int dist[N],cnt[N];//距离，cnt:当前最短路径的边数
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()
{
    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[j]>=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);//读入m条边
    }
    
  if(spfa()) puts("Yes");
  else puts("No");
   

    return 0;
}

Floyd算法

开始的时候d[i,j]：是邻接矩阵，存的所有的边

结束的时候d[i,j]:存的是i到j的最短的长度

d[k,i,j]:从i到j只经历过1到k这些个中间点

例题：Floyd求最短路

给定一个 n个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。

数据保证图中不存在负权回路。

输入格式

第一行包含三个整数 n,m,k

接下来 m 行，每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边，边长为 z。

接下来 k 行，每行包含两个整数 x,y表示询问点 x到点 y 的最短距离。

输出格式

共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。

数据范围

1≤n≤200
1≤k≤n2
1≤m≤20000
图中涉及边长绝对值均不超过 10000

输入样例：

输出样例：

impossible
1

解题代码：

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

using namespace std;

const int N=210,INF=1e9;

int n,m,Q;//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,w;
        scanf("%d%d%d",&a,&b,&w);
        
        d[a][b]=min(d[a][b],w);//有多条边只保留最小边
    }
    floyd();
    
    while(Q--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        
        if(d[a][b]>INF/2) puts("impossible");
        else printf("%d\n",d[a][b]);
    }
    
    return 0;
}