几种最短路

最新推荐文章于 2022-06-30 10:46:39 发布

觅失Yi

最新推荐文章于 2022-06-30 10:46:39 发布

阅读量75

点赞数

文章标签：数据结构图论

本文链接：https://blog.csdn.net/qq_45682511/article/details/121719529

版权

                             **Floyd求最短路 O(N³)**

给定一个 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。

输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1

#include <bits/stdc++.h>

using namespace std;
#define inf 0x3f3f3f3f
int dis[250][250];
int a[250][250];
int n,m,k;
void floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
            }
        }
    }
}
int main()
{
    cin >> n >>m >>k;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
            {
                dis[i][j]=0;
            }
            else
            dis[i][j]=inf;
        }
    }
    for(int i=1;i<=m;i++)
    {
        int s,e,w;
        cin >>s >>e >>w;
        dis[s][e]=min(dis[s][e],w);
    }
    floyd();
    while(k--)
    {
        int s,e;
        cin >>s >>e ;
        if(dis[s][e]>inf/2)
        cout <<"impossible"<<endl;
        else
        cout <<dis[s][e]<<endl;
    }


    return 0;
}

             **Dijkstra求最短路（朴素版O(N²) 、堆优化版 O(M LogN)**

给定一个 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。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

#include <bits/stdc++.h>

using namespace std;
int n,m;
const int N = 100010;
int head[N],dis[N];
int vis[N];
struct node
{
    int to,w;
    int ne;
}a[N];
int cnt;
void add(int x,int y,int z)
{
    cnt++;
    a[cnt].to=y;
    a[cnt].w=z;
    a[cnt].ne = head[x];
    head[x]=cnt;
}
void dijkstra()
{
    priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int>> > q;
    q.push({0,1});
    while(!q.empty())
    {
        int x = q.top().second;
        q.pop();
        if(vis[x])
        continue;
        vis[x]=1;
        
        for(int i = head[x];i!=-1;i=a[i].ne)
        {
            int xx = a[i].to;
            if(dis[xx]>a[i].w+dis[x])
            {
                dis[xx]=a[i].w+dis[x];
                q.push({dis[xx],xx});
            }
        }
    }
    if(dis[n]==0x3f3f3f3f)
    cout <<"-1";
    else
    cout <<dis[n];
}
int main()
{
    cin >> n >>m;
    memset(dis,0x3f3f3f3f,sizeof(dis));
    memset(head,-1,sizeof(head));
    dis[1]=0;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin >> x >>y >>z;
        add(x,y,z);
    }
    dijkstra();
    
    return 0;
}

           **bellman-ford 应用 ——有边数限制的最短路 (O (MN) )**

给定一个 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。

输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3

#include <bits/stdc++.h>

using namespace std;
struct node
{
    int u,v,w;
}a[10010];
int dis[10010];
int back[10010];
int n,m,k;
void bellman_ford()
{
    memset(dis,0x3f,sizeof(dis));
    dis[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(back,dis,sizeof(dis));
        for(int j=0;j<m;j++)
        {
            int x=a[j].u,y=a[j].v,z=a[j].w;
            
           dis[y] = min(dis[y],back[x]+z);
        }
    }
    if(dis[n]>0x3f3f3f3f/2)
    cout <<"impossible";
    else
    cout <<dis[n];
}
int main()
{
    cin >> n >>m>> k;
    for(int i=0;i<m;i++)
    {
        int x,y,z;
        cin >>x>>y>>z;
        a[i]={x,y,z};
    }
    bellman_ford();
    
    
    
    return 0;
}

                          spfa求最短路(一般O（M）最坏O（NM）)

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

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

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

输入格式
第一行包含整数 n 和 m。

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

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

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

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

输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2

#include <bits/stdc++.h>

using namespace std;
int n,m;
int cnt;
int dis[100010];
int head[100010];
bool st[100010];
struct node
{
    int ne,to,w;
}a[100010];
bool s;
void add(int x,int y,int z)
{
    cnt++;
    a[cnt].to=y;
    a[cnt].w=z;
    a[cnt].ne=head[x];
    head[x]=cnt;
}
void spfa()
{
    queue<int> q;
    q.push(1);
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        st[now]=false;
        for(int i=head[now];i!=-1;i=a[i].ne)
        {
            int xx=a[i].to,yy=a[i].w;
            if(dis[xx]>dis[now]+yy)
            {
                dis[xx]=dis[now]+yy;
                if(!st[xx])
                {
                    q.push(xx);
                    st[xx]=true;
                }
            }
            
        }
    }
    if(dis[n]>0x3f3f3f3f/2)
    cout <<"impossible";
    else 
    cout <<dis[n];
}
int main()
{
    cin >> n >>m;
    memset(head,-1,sizeof(head));
     memset(dis,0x3f,sizeof(dis));
     dis[1]=0;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin >>x>> y >>z;
        add(x,y,z);
    }
    spfa();
    return 0;
}

                           spfa判断负环

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

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

输入格式
第一行包含整数 n 和 m。

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

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

数据范围
1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3
1 2 -1
2 3 4
3 1 -4
输出样例：
Yes

#include <bits/stdc++.h>

using namespace std;
bool st[2100],num[2100];
int dis[2100],head[21000];
struct node
{
    int ne,w,to;
}a[21000];
int cnt;
void add(int x,int y,int z)
{
    cnt++;
    a[cnt].to=y;
    a[cnt].w=z;
    a[cnt].ne=head[x];
    head[x]=cnt;
}
int n,m;
void spfa()
{
    queue<int> q;
    
    for(int i=1;i<=n;i++)
    {
        q.push(i);
        st[i]=true;
    }
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        st[now]=false;
        for(int i=head[now];i!=-1;i=a[i].ne)
        {
            int xx=a[i].to,ww=a[i].w;
            if(dis[xx]>dis[now]+ww)
            {
                dis[xx]=dis[now]+ww;
                num[xx]=num[now]+1;
                if(num[xx]>=n)
                {
                    cout <<"Yes";
                    exit(0);
                }
                if(!st[xx])
                {
                    st[xx]=true;
                    q.push(xx);
                }
            }
        }
    }
    cout <<"No";
}
int main()
{
    cin >> n >>m;
    memset(head,-1,sizeof(head));
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin >> x >> y>>z;
        add(x,y,z);
    }
    memset(dis,0x3f,sizeof(dis));
    dis[1]=0;
    spfa();
    return 0;
}