图论之最短路问题题目集

最新推荐文章于 2022-10-09 10:09:10 发布
最新推荐文章于 2022-10-09 10:09:10 发布
阅读量654 收藏 2
点赞数 4
分类专栏： 图论 文章标签： 图论 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51282224/article/details/120873098
版权
本文详细介绍了各种最短路径算法，包括Dijkstra、堆优化Dijkstra、Bellman-Ford、SPFA等，并提供了多源最短路算法如Floyd。通过实例解析，展示了如何在不同场景下运用这些算法解决实际问题，如热浪、信使、香甜的黄油、昂贵的聘礼等。此外，还讨论了带限制条件的最短路求解策略，如通信线路和最优贸易问题。
摘要由CSDN通过智能技术生成

注意事项
1.最短路问题的难点不在于算法，而在于建图方式
2.需要挖掘题目中隐藏的条件单、双向图，是否存在负环，是否有重边等等
3.往往不只简单图论还会和其他知识点一起出

第一部分————模板

一.单源最短路

dijkstra算法

注意：边权必须为非负

1.Dijkstra求最短路 I

稠密图用邻接矩阵

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510;
int g[N][N];
int dist[N];
bool st[N];
int n,m;
int dij()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[t]>dist[j]))
            {
                t=j;
            }
        }
        st[t]=true;
        
        for(int j=1;j<=n;j++)
        {
            dist[j]=min(dist[j],dist[t]+g[t][j]);
        }
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];
    
}
int main()
{
    int a,b,c;
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while (m -- )
    {
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }
    cout<<dij()<<endl;
}
2.堆优化版的dijkstra
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 1000010;
int e[N],ne[N],w[N],h[N],idx;
int n,m;
bool st[N];
int dist[N];

void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int dij()
{
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    heap.push({0,1});
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        int ver=t.second;
        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/2)return -1;
    else return dist[n];
    
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    int a,b,c;
    while (m -- ){
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<dij()<<endl;
}
3.有边数限制的最短路 bellman-ford算法
边权可以为负数
可以用来找负环，第n次有更新的话证明有负环

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 10010;
struct Edge{
    int a,b,c;
}ed[N];
int n,m,k;
int dist[N];
int last[N];
void ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(last,dist,sizeof dist);
        for(int j=0;j<m;j++)
        {
            auto e=ed[j];
            dist[e.b]=min(dist[e.b],last[e.a]+e.c);
        }
    }
}
int main()
{
    cin>>n>>m>>k;
    int a,b,c;
    for(int i=0;i<m;i++)
    {
        cin>>a>>b>>c;
        ed[i]={a,b,c};
    }
    ford();
    if(dist[n]>0x3f3f3f3f/2)cout<<"impossible"<<endl;
    else cout<<dist[n]<<endl;
}
5.有负权求最短路 spfa算法
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int N = 100010;
int e[N],ne[N],h[N],w[N],idx=0;
int dist[N];
bool st[N];
int n,m;
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;
    q.push(1);
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    st[1]=true;
    while(q.size())
    {
        auto 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()
{
    cin>>n>>m;
    memset(h, -1, sizeof h);
    int a,b,c;
    while (m -- )
    {
        cin>>a>>b>>c;
        add(a,b,c);
    }
    int res=spfa();
    if(res==0x3f3f3f3f)cout<<"impossible"<<endl;
    else cout<<res<<endl;
}

6.spfa求负环

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int e[N],ne[N],w[N],h[N],idx=0;
bool st[N];
int n,m;
int dist[N];
int cnt[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++)
    {
        q.push(i);
        st[i]=true;
    }
    while(q.size())
    {
        auto 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])
            {
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n)return true;
                dist[j]=dist[t]+w[i];
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    return false;
}
int main()
{
    cin>>n>>m;
    int a,b,c;
    memset(h,-1,sizeof h);
    while (m -- )
    {
        cin>>a>>b>>c;
        add(a,b,c);
    }
    if(spfa())cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}

二.多源汇最短路

1.floyd算法

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210;
const int INF = 0x3f3f3f3f;
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()
{
    cin>>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;
    
    int a,b,c;
    while (m -- )
    {
        cin>>a>>b>>c;
        d[a][b]=min(d[a][b],c);
    }
    floyd();
    
    while(q--)
    {
        cin>>a>>b;
        int t=d[a][b];
        if(t>0x3f3f3f3f/2)cout<<"impossible"<<endl;
        else cout<<t<<endl;
    }
}

第二部分————练习题

1.热浪----dijkstra

链接

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

typedef pair<int, int> PII;
typedef long long LL;
const int N = 6220*2,M=2520;
int dist[M];
bool st[M];
int h[M],e[N],w[N],ne[N],idx=0;
int n,m,ss,ee;
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int dij(int ss,int ee)
{
    memset(dist,0x3f,sizeof dist);
   // priority_queue<PII, vector<PII>, greater<PII> > heap;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0,ss});
    dist[ss]=0;
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        int ver=t.second;
        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});
            }
        }
    }
    return dist[ee];
}

int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m>>ss>>ee;
    int a,b,c;
    while (m -- ){
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    cout<<dij(ss,ee)<<endl;
}

2.信使----floyd

链接

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210;
int d[N][N];
int n,m;
int main()
{
    int a,b,c;
    cin>>n>>m;
    memset(d,0x3f,sizeof d);
    d[1][1]=0;
    
    while (m -- ){
        cin>>a>>b>>c;
        d[a][b]=d[b][a]=min(d[a][b],c);
    }
    
    
    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][k]+d[k][j],d[i][j]);
             
    int res=0;
    
    for(int i=2;i<=n;i++)
    {
        if(d[1][i]==0x3f3f3f3f)
        {
            cout<<"-1"<<endl;
            return 0;
        }
        else res=max(res,d[1][i]);
    }
    cout<<res<<endl;
}

3.香甜的黄油----dijkstra

链接

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;

const int N = 3000;
int e[N],h[N],w[N],ne[N],idx=0;
int dist[N],id[N];
bool st[N];
int n,p,m;
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int dij(int ss)
{
    memset(st,0,sizeof st);
    memset(dist,0x3f,sizeof dist);
    priority_queue<PII,vector<PII>,greater<PII>>q;
    q.push({0,ss});
    dist[ss]=0;
    
    while(q.size())
    {
        auto t=q.top();
        q.pop();
        
        int ver=t.second;
        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];
                q.push({dist[j],j});
            }
        }
    }
    int res=0;
    for(int i=1;i<=n;i++)
    {
        if(dist[id[i]]==0x3f3f3f3f)return 0x3f3f3f3f;
        else
        res+=dist[id[i]];
    }
    return res;
}

int main()
{
    cin>>n>>p>>m;
    memset(h,-1,sizeof h);
    int x;
    for(int i=1;i<=n;i++)
    {
        cin>>id[i];
    }
    int a,b,c;
    while (m -- )
    {
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    int res=0x3f3f3f3f;
    for(int i=1;i<=p;i++)
    {
        res=min(res,dij(i));
    }
    cout<<res<<endl;
}

4.最小花费----朴素版dijkstra

链接

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 2010;
int n,m,ss,tt;
double g[N][N];
double dist[N];
bool st[N];
void dij()
{
    dist[ss]=1;
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[t]<dist[j]))
            {
                t=j;
            }
        }
        
        st[t]=true;
        for(int j=1;j<=n;j++)
        {
            dist[j]=max(dist[j],dist[t]*g[t][j]);
        }
    }
}
int main()
{
    cin>>n>>m;
    int a,b,c;
    while (m -- )
    {
        cin>>a>>b>>c;
        double t=(100.0-c)/100.0;
        g[a][b]=g[b][a]=max(g[a][b],t);
    }
    cin>>ss>>tt;
    dij();
    printf("%.8lf\n",100/dist[tt]);
}

5.最优乘车----bfs+建图

链接

#include <iostream>
#include <cstring>
#include <algorithm>
#include <sstream>
using namespace std;
const int N = 1000;
int g[N][N];
int n,m;
int dist[N],q[N];
int cnt=0;
int stop[N]; 
void bfs()
{
    int hh=0,tt=-1;
    memset(dist,0x3f,sizeof dist);
    q[++tt]=1;
    dist[1]=0;
    while(hh<=tt)
    {
        auto t=q[hh++];
        
        for(int i=1;i<=n;i++)
        {
            if(g[t][i]&&dist[i]==0x3f3f3f3f)
            {
                dist[i]=dist[t]+1;
                q[++tt]=i;
            }
            
        }
    }
}
int main()
{
    cin>>m>>n;
    string s;
    getline(cin,s);
    while (m -- )
    {
        getline(cin,s);
        stringstream ssin(s);
        int p,cnt=0;
        while(ssin>>p)stop[cnt++]=p;
        for(int i=0;i<cnt;i++)
           for(int j=i+1;j<cnt;j++)
              g[stop[i]][stop[j]]=true;
        
    }
    bfs();
    if(dist[n]==0x3f3f3f3f)cout<<"NO"<<endl;
    else cout<<max(dist[n]-1,0)<<endl;
}

6.昂贵的聘礼----朴素版dijkstra+有限制的建图方式+虚拟原点

题目链接

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110,INF=0x3f3f3f3f;
int g[N][N];
int level[N];
int dist[N];
bool st[N];
int n,m;
int dij(int ss,int ee)
{
    memset(st, 0, sizeof st);
    memset(dist,0x3f,sizeof dist);
    dist[0]=0;
    for(int i=0;i<=n;i++)
    {
        int t=-1;
        for(int j=0;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[t]>dist[j]))
            {
                t=j;
            }
        }
        st[t]=true;
        
        for(int j=1;j<=n;j++)
        {
            if(level[j]>=ss&&level[j]<=ee)
            {
                dist[j]=min(dist[j],dist[t]+g[t][j]);
            }
        }
    }
    return dist[1];
}
int main()
{
    cin>>m>>n;
    memset(g,0x3f,sizeof g);
    for(int i=1;i<=n;i++)g[i][i]=0;
    for(int i=1;i<=n;i++)
    {
        int w,cnt;
        cin>>w>>level[i]>>cnt;
        g[0][i]=min(g[0][i],w);
        while(cnt--)
        {
            int a,b;
            cin>>a>>b;
            g[a][i]=min(g[a][i],b);
        }
        
    }
    int res=INF;
    for(int i=level[1]-m;i<=level[1];i++)res=min(res,dij(i,i+m));
    cout<<res<<endl;
}

7.新年好

算法：建图+堆优化dijkstra+dfs+暴力

链接

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 50010,M=200010;
const int INF = 0x3f3f3f3f;
int h[N],w[M],e[M],ne[M],idx=0;
bool st[N];
int dist[6][N];
int n,m;
int source[6];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void dij(int ss,int dist[])
{
    memset(dist,0x3f,N*4);
    memset(st, 0, sizeof st);
    priority_queue<PII,vector<PII>,greater<PII> >q;
    dist[ss]=0;
    q.push({0,ss});
    while(q.size())
    {
        auto t=q.top();
        q.pop();
        int ver=t.second;
        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];
                q.push({dist[j],j});
            }
        }
    }
}
int dfs(int u,int ss,int distance)
{
    if(u>5)return distance;
    int res=INF;
    for(int i=1;i<=5;i++)
    {
        
        if(!st[i])
        {
            int next=source[i];
            st[i]=true;
            res=min(dfs(u+1,i,distance+dist[ss][next]),res);
            st[i]=false;
        }
    }
    return res;
}
int main()
{
    memset(h,-1,sizeof h);
    cin>>n>>m;
    for(int i=1;i<6;i++)cin>>source[i];
    source[0]=1;
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    for(int i=0;i<6;i++)dij(source[i],dist[i]);
    
    memset(st,0,sizeof st);
    cout<<dfs(1,0,0)<<endl;
}

8.通信线路

最大值最小一般都可以二分来做
这题的难点在于对结果的限制条件k，求结果最大值最小，用二分，把大于答案的边长度设为1，小于答案的边为0，求0，1路径可用双端队列求解，是代码更加简练
链接

#include <iostream>
#include <cstring>
#include <algorithm>
#include <deque>
using namespace std;
const int N = 1010,M=20010;
int h[N],w[M],e[M],ne[M],idx=0;
int n,p,k;
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++;
}
bool check(int bound)
{
    memset(st, 0, sizeof st);
    memset(dist,0x3f,sizeof dist);
    
    deque<int>q;
    q.push_back(1);
    dist[1]=0;
    
    while(q.size())
    {
        int t=q.front();
        q.pop_front();
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i],x=w[i]>bound;
            if(dist[j]>dist[t]+x)
            {
                dist[j]=dist[t]+x;
                if(!x)q.push_front(j);
                else q.push_back(j);
            }
        }
        
    }
    return dist[n]<=k;
}
int main()
{
    memset(h,-1,sizeof h);
    cin>>n>>p>>k;
    int a,b,c;
    while(p--)
    {
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    int l=0,r=1e6+1;
    while(l<r)
    {
        int mid=l+r>>1;
        if(check(mid))r=mid;
        else l=mid+1;
    }
    if(r==1e6+1)cout<<-1<<endl;
    else cout<<r<<endl;
}

9.道路与航线–dfs+topsort+dijkstra+建图方式

算法流程

1.先输入所有双向道路，然后DFS出所有连通块，计算两个数组:id[]存储每个点属于哪个连通块;vector<int> block[]存储每个连通块里有哪些点:
2.输入所有航线，同时统计出每个连通块的入度。
3.按照拓扑序依次处理每个连通块，先将所有入度为0的连通块的编号加入队列
中。
4.每次从队头取出一个连通块的编号bid
5.将该block[bid]中的所有点加入堆中，然后对堆中所有点跑dijkstra算法。
6.每次取出堆中距离最小的点ver。
7.然后遍历ver的所有邻点j。如果id[ver]==id[]，那么如果j能被更新，则将j插入堆中:如果id[ver]!= id[j]，则将id[j]这个连通块的入度减1，如果减成0了，则将其插入拓扑排序的队列中

题目链接

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

typedef long long LL;
typedef pair<int, int> PII;
#define x first
#define y second

const int N = 25010,M=150010;
int h[N],e[M],ne[M],w[M],idx=0;

int dist[N];
bool st[N];
vector<int>block[N];
int bcnt=0;
int id[N];
int n,rm,pm,s;
int din[N];
queue<int>q;
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u,int bid)
{
    id[u]=bid;
    block[bid].push_back(u);
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!id[j])
        {
            dfs(j,bid);
        }
    }
}
void dij(int bid)
{
    memset(st, 0, sizeof st);
    priority_queue<PII,vector<PII>,greater<PII> >heap;
    
    for(auto u:block[bid])
    {
        heap.push({dist[u],u});
    }
    
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        
        int ver=t.second;
        if(st[ver])continue;
        st[ver]=true;
        
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(id[j]!=id[ver]&&--din[id[j]]==0)q.push(id[j]);
            if(dist[j]>dist[ver]+w[i])
            {
                dist[j]=dist[ver]+w[i];
                if(id[j]==id[ver])heap.push({dist[j],j});
            }
        }
        
    }
}
void topsort()
{
    memset(dist,0x3f,sizeof dist);
    dist[s]=0;
    for(int i=1;i<=bcnt;i++)
    {
        if(din[i]==0)
        {
            q.push(i);
        }
    }
    while(q.size())
    {
        int t=q.front();
        q.pop();
        dij(t);
    }
}
int main()
{
    memset(h,-1,sizeof h);
    cin>>n>>rm>>pm>>s;
    int a,b,c;
    while(rm--)
    {
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    for(int i=1;i<=n;i++)
    {
        if(!id[i])
        {
            dfs(i,++bcnt);
        }
    }
    
    while(pm--)
    {
        cin>>a>>b>>c;
        din[id[b]]++;
        add(a,b,c);
    }
    topsort();
    for(int i=1;i<=n;i++)
    {
        if(dist[i]>0x3f3f3f3f/2)cout<<"NO PATH"<<endl;
        else cout<<dist[i]<<endl;
    }
}

10.最优贸易

题目链接

双spfa同时进行
先求出：

从 1 走到 i的过程中，买入水晶球的最低价格 dmin[i]；
从 i走到 n 的过程中，卖出水晶球的最高价格 dmax[i]；
然后枚举每个城市作为买卖的中间城市，求出 dmax[i] - dmin[i]的最大值即可。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010,M=2000010;
int h[N],rh[N],e[M],ne[M],idx=0;
int n,m;
int dist[N];
bool st[N];
int dmax[N],dmin[N];
void add(int h[],int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void spfa(int d[],int start,int h[],bool flag)
{
    queue<int>q;
    memset(st,0,sizeof st);
    if(flag)memset(d,0x3f,sizeof dmin);
    q.push(start);
    d[start]=dist[start];
    st[start]=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(flag&&d[j]>min(d[t],dist[j])||!flag&&d[j]<max(d[t],dist[j]))
            {
                if(flag){
                    d[j]=min(d[t],dist[j]);
                }
                else d[j]=max(d[t],dist[j]);
                
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    memset(h, -1, sizeof h);
    memset(rh,-1,sizeof rh);
    for(int i=1;i<=n;i++)cin>>dist[i];
    while (m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
            add(h,a,b);
            add(rh,b,a);
        if(c==2)
        {
            add(h,b,a);
            add(rh,a,b);
        }
    }
    
    spfa(dmin,1,h,true);
    spfa(dmax,n,rh,false);
    
    int res=0;
    for(int i=1;i<=n;i++)res=max(res,dmax[i]-dmin[i]);
    cout<<res<<endl;
}

11.选择最佳线路

添加链接描述

稠密图，用邻接矩阵，建立超级原点。
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
int n,m,s;
const int N = 1010;
int g[N][N];
bool st[N];
int dist[N];
void dij()
{
    memset(st,0,sizeof st);
    
    dist[0]=0;
    
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=0;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[t]>dist[j]))
            {
                t=j;
            }
        }
        st[t]=true;
        for(int i=1;i<=n;i++)
        {
            dist[i]=min(dist[i],dist[t]+g[t][i]);
        }
    }
    
}
int main()
{
    int a,b,c,x,cnt;
    while(~scanf("%d%d%d",&n,&m,&s))
    {
        memset(g,0x3f,sizeof g);
        memset(dist,0x3f,sizeof dist);
        while (m -- )
        {
            cin>>a>>b>>c;
            g[a][b]=min(g[a][b],c);
        }
        cin>>cnt;
        for(int i=0;i<cnt;i++)
        {
            cin>>x;
            g[0][x]=0;
        }
        dij();
        if(dist[s]==0x3f3f3f3f)cout<<-1<<endl;
        else cout<<dist[s]<<endl;
    }
}

12.最短路计数

题目链接

这道题比较新奇，同时使用bfs时不需要设置st数组，类似于spfa的松弛操作
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int N = 100010,M=400010;
const int mod = 100003;
int h[N],e[M],ne[M],idx=0;
int dist[N];
int n,m;
int cnt[N];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void bfs()
{
    memset(dist,0x3f,sizeof dist);
    cnt[1]=1;
    dist[1]=0;
    queue<int>q;
    q.push(1);
    while(q.size())
    {
        int t=q.front();
        q.pop();
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[t]+1)
            {
                dist[j]=dist[t]+1;
                cnt[j]=cnt[t];
                q.push(j);
            }
            else if(dist[j]==dist[t]+1)
            {
                cnt[j]=(cnt[j]+cnt[t])%mod;
            }
        }
    }
    
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    int a,b;
    while (m -- ){
        cin>>a>>b;
        add(a,b);
        add(b,a);
    }
    bfs();
    for(int i=1;i<=n;i++)cout<<cnt[i]<<endl;
}

13.牛的旅行

多源汇最短路Floyd算法

题目链接

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

using namespace std;
#define x first
#define y second

typedef pair<double, double> PDD;
const int N = 155;
PDD q[N];
const double INF = 1e20;
double d[N][N];
int n;
double maxd[N];
char g[N][N];
double get_dist(PDD a,PDD b)
{
    double dx=a.x-b.x;
    double dy=a.y-b.y;
    return sqrt(dx*dx+dy*dy);
}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
          cin>>q[i].x>>q[i].y;
          
    for(int i=0;i<n;i++)cin>>g[i];
    
    for(int i=0;i<n;i++)
       for(int j=0;j<n;j++)
          {
              if(i==j)d[i][j]=0;
              else if(g[i][j]=='1')d[i][j]=get_dist(q[i],q[j]);
              else d[i][j]=INF;
          }
          
    for(int k=0;k<n;k++)
       for(int i=0;i<n;i++)
          for(int j=0;j<n;j++)
             d[i][j]=min(d[i][k]+d[k][j],d[i][j]);
    
    double res1=0;
    for(int i=0;i<n;i++)
    {
       for(int j=0;j<n;j++)
          if(d[i][j]<INF/2)maxd[i]=max(maxd[i],d[i][j]);
          
          res1=max(maxd[i],res1);
     
    }      
    double res2=INF;
    
    for(int i=0;i<n;i++)
       for(int j=0;j<n;j++)
          if(d[i][j]>INF/2)
          {
              res2=min(res2,maxd[i]+maxd[j]+get_dist(q[i],q[j]));
          }
    printf("%.6lf",max(res1,res2));
}

14.排序

多源汇最短路Floyd算法
#include <iostream>
#include <cstring>
#include <algorithm>
#include<cstdio>
using namespace std;
const int N = 26;
int n,m;
bool g[N][N],d[N][N];
bool st[N];
void floyd(){
    memcpy(d,g,sizeof d);
    for(int k=0;k<n;k++)
       for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
           d[i][j]|=d[i][k]&&d[k][j];
}
int check(){
    for(int i=0;i<n;i++)
       if(d[i][i])
         return 2;
    for(int i=0;i<n;i++)
       for(int j=0;j<i;j++)
          if(!d[i][j]&&!d[j][i])
             return 0;
    return 1;
    
}
char get_min(){
    for(int i=0;i<n;i++)
        if(!st[i]){
            bool flag=true;
            for(int j=0;j<n;j++)
               if(!st[j]&&d[j][i]){
                   flag=false;
                   break;
               }
            if(flag){
                st[i]=true;
                return 'A'+i;
            }
        }
}
int main()
{
    while(cin>>n>>m,n||m){
        memset(g,0,sizeof g);
        int type=0,t;
        for(int i=1;i<=m;i++){
            char str[5];
            cin>>str;
            int a=str[0]-'A',b=str[2]-'A';
            if(!type){
                g[a][b]=1;
                floyd();
                type=check();
                if(type)t=i;
            }
        }
        if(!type)puts("Sorted sequence cannot be determined.");
        else if(type==2)printf("Inconsistency found after %d relations.\n", t);
        else {
            memset(st, 0, sizeof st);
            printf("Sorted sequence determined after %d relations: ", t);
            for(int i=0;i<n;i++)printf("%c",get_min());
            printf(".\n");
        }
    }
}
_WAWA鱼_
关注
专栏目录
最短路习题
Jackzhan的博客
08-13 676
有限制最短路（枚举+最短路） 分层图最短路
【图论】最短路问题大合集，五种算法刷爆最短路问题。
最新发布
m0_70875482的博客
10-22 833
思路：迭代n次，每次找到距离离起点最近的点，起点置为0，并且用距离最近的点更新其他点。题目：给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。输入格式：第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。输出格式：输出一个整数，表示 1 号点到 n 号点的最短距离。
道路与航线——图论综合性最短路问题，综合性太强把他单独拎出来了
ZZU_LGY
10-23 226
道路与航线–dfs+topsort+dijkstra+建图方式 算法流程 1.先输入所有双向道路，然后DFS出所有连通块，计算两个数组:id[]存储每个点属于哪个连通块;vector<int> block[]存储每个连通块里有哪些点: 2.输入所有航线，同时统计出每个连通块的入度。 3.按照拓扑序依次处理每个连通块，先将所有入度为0的连通块的编号加入队列 中。 4.每次从队头取出一个连通块的编号bid 5.将该block[bid]中的所有点加入堆中，然后对堆中所有点跑dijkstra算法。 6.
最短路题目题解
Z7784562的博客
11-26 378
POJ2387(dijkstra) POJ1502(floyd) POJ1847(floyd) POJ3268(dijkstra+反向存图)
【图论】最短路总结+例题
weixin_43819578的博客
08-30 3175
板子 迪杰斯特拉普通板子 void dli(){ memset(d,0x3f,sizeof(d));//memset可能会错，最好用循环赋值 memset(v,0,sizeof(v)); d[1]=0;//起点的距离是0 for(int i=1;i<n;i++){ int x=0; for(int j=1;j<=n;j++){ if(!v[j]&&...
图论之最短路问题（acwing模板篇）
lihua777的博客
02-14 875
acwing(6)
图论之最短路
d22HgH22b的博客
04-12 416
.
图论中的最短路问题免费下载
09-20
最短路 图论 算法 图论中的最短路问题一些问题，求解方法。。。。。。。。。。。
图论基础之最短路和最小生成树
m0_55341679的博客
10-09 532
最短路和最小生成树
图论之最短路习题
weixin_30675247的博客
02-27 163
1.P1144 最短路计数 算法思路：邻接表存图，边权为1，spfa模板 　　if(dis[to]>dis[u]+mp[u][to]) num[to]=num[u]; 　　else if(dis[to]==dis[u]+mp[u][to]) num[to]=(num[to]+num[u])%mod; 注意重边和自环；在运用spfa进行动态逼近松弛时，如果有一个点能被松驰，则代表有一条...
最短路总结（题目合集）
常胜将军的博客
08-21 1005
1、HDU 6670 Mindis（建图+最短路） 题意： Description 平面上有 n 个矩形，矩形的边平行于坐标轴，现在度度熊需要操控一名角色从 A 点走到 B 点。 该角色可以上下左右移动，在恰被 k 个矩形覆盖的区域，该角色的速率为 k+1 个距离/秒（矩形覆盖区域包括边界）。 请求出 A 移动到 B 最快需要多少秒。 Input 第一行一个整数 T (1≤T≤5) 表示...
最短路专题练习
zhuml123的专栏
10-23 518
一、入门难度 1、HDU 2544（一级） 【题意】 给出n个顶点m条边，以及每条边的权值为w，求1到n的最短路 【思路】 裸题 2、HDU 2066 (一级) 【题意】 因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。 【思路】 这道题其实一次Dijkstra就可以了，我们将草儿的家看做0，从草儿家到相邻镇的花费看做0，那么我们就只需要求草...
图论-最短路问题
The Shawshank Redemption
08-18 752
最短路旨在解决这样一种问题，在图中，需要知道从点i到点j的路径长度的最小值。 松弛操作： 在最短路中，我们需要做松弛操作，即当我们能够找到一个点k使得i->j能够通过k做中转变得更小，即满足i->j < i->k + k->j ，此时我们将i->j 更新为i->k + k->j，此为松弛操作。 多源最短路 Folyd算法： Folyd算法采用动态规划的算法，我们这样抽象问题：在考察n个点的情况下，求i->j的最短路径长度。当我们考察是否能够..
最短路题单练习
qq_52280112的博客
08-05 308
思路：我们可以改变dijkstra的dis数组的含义，即所有点到点v的路径上的最小值，例如现在有一条路径为 u->v,我们可以用 dis[u] 和 len（u->v）的长度取最大，再用此时的得到的值，与dis[v]取最小。题目大意：N个点，M条边，每条边有权值。求一条1号点到N号点的路径，要求使得路径中的边权最小值最大。思路：这道题和上一道思路类似，我们可以改变dis数组的含义，在更新dis的过程中与上一道题相反即可。题目大意：求所有路径中的最长的边，在这些最长边中找到最小值并输出。.........
最短路题组题解
weixin_63638351的博客
02-14 767
目录 P1629 邮递员送信 P3371 【模板】单源最短路径（弱化版） P4779 【模板】单源最短路径（标准版） P1359 租用游艇 P2910 [USACO08OPEN]Clear And Present Danger S P1339 [USACO09OCT]Heat Wave G P1629 邮递员送信 思路分析： 这道题我采用的是Bellman-Ford算法，第一步求从源点1到其他点的距离直接套用模板就行。但是第二步需要回到源点1，由于题目说所有的路线都是单...
最短路问题模板题POJ2387
codechairmanyuan的博客
08-01 635
   对于最短路问题，经常用的两种算法必然是dijkstra算法和SPFA算法，SPFA算法虽然可以解决负权值问题和不需要考虑重边，但是其存在时间不稳定性，所以在单纯的无负权值问题解决方面是不如dijkstra算法的。 下面用POJ2378来介绍两种算法的模板，一般题型可以直接套用。   Bessie is out in the field and wants to get back to t...
最短路问题（——模板习题与总结）
aisebu7819的博客
07-25 452
　　摘要：本文主要讲解在竞赛中如何求解图中存在环的最短路问题。其中涉及的算法有Floyd算法，Dijkstra算法，使用邻接表和优先队列优化的Dijkstra算法，Bellman-Ford算法，简要总结各算法的基本思想和实现以及使用注意事项。 　　最短路问题主要分为单源最短路问题和多源最短路问题。给出顶点数和边数，以及边的权值，让我们计算从某个顶点到某个顶点的最短路径，单源最短路就是求...
ACM竞赛题库精华：图论与最短路问题解析
"这篇资源主要汇总了ACM竞赛相关的题目，包括图论、网络流、字符串等多个主题，并提供了几个具体涉及最短路问题的题目及其解题报告链接。" 在ACM（国际大学生程序设计竞赛）中，参赛者需要解决各种算法问题，提升...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_WAWA鱼_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值