最短路习题

最新推荐文章于 2022-08-05 18:55:04 发布

Cheng Yu

最新推荐文章于 2022-08-05 18:55:04 发布

阅读量431

点赞数

分类专栏：习题图论

本文链接：https://blog.csdn.net/qq_17080419/article/details/108568429

版权

习题同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

图论

4 篇文章 0 订阅

订阅专栏

最短路习题

算法概述

Bellman - Ford 算法

适用于计算有向图负边权的单源最短路径
算法流程：

设 $d i s [n]$ 为源点S到各个点的距离， $d i s [S]$ 设为0，其余点设为inf
设有n个点，m条边。对m条边执行松弛操作，即当 $d i s [u] > d i s [v] + w (u, v)$ ，取 $d i s [u] = d i s [v] + w (u, v)$ ，循环n-1次。
（理论上：当没有松弛操作时，即可跳出循环。但如果出现了负环，那么松弛操作可以做无限次。其实，每次对m条边做松弛操作，都可以使最短路+1，因此最多只需做n-1次，如果没到n-1次，就不执行松弛操作了，也可以提前跳出循环）
对m条边进行判断：如果存在dis[u]>dis[v]+w(u,v)说明存在负环，则无法得出最短路。否则dis数组中的每个点都是最短路

应用：判负环
时间复杂度： $O (n m)$ ，n为点集大小，m为边集大小

问题：为什么出现 $d (u) > d (v) + w (u, v)$ 的情况，说明出现了负权环？
解释：首先在流程2中我们一直在做 $d [u] = m i n (d [u], d [v] + w (u, v))$ 的操作。但由于我们的更新操作是单向的，永远都是拿点v来更新点u，那么在第一次更新的时候 $d [u] = d [v] + w (u, v)$ ，但是在负环上单向更新，累积权值<0。第二次更新到d[v]的时候， $d [v]$ 由于负权值会变小。这样就出现了 $d (u) > d (v) + w (u, v)$ 的情况。
简单的说就是d[v]在负环上第二次更新的值比第一次更新的值小，如果一直做松弛操作就会一直变小。

SPFA 算法

原理：SPFA算法是对Bellman_Ford算法的优化，只有上一次被松弛过的节点相连的边才有可能做松弛操作，因此用一个队列来维护可能做松弛操作的边。

算法流程：

设 $dis_i$ 为源点 s 到点 i 的距离， $d i s [s]$ 设为 0 ，其余点设为 inf ，将源点入队并设为以访问
每次弹出队首节点，标记为未访问，遍历与它相邻的节点做松弛操作，如果可松弛那么就标记为已访问并入队。
用num数组记录入队次数，如果入队次数为n那么就存在负环，无法求得最短路

总结：用队列维护可松弛的点，每次弹出一个点，对相邻点做松弛操作，如果可松弛且不再队列中，就将它入队并记录次数，当次数达到 n 次时，说明存在负环。

两个优化：https://www.cnblogs.com/Yangrui-Blog/p/8997721.html

Dijkstra 算法

dijkstra的本质就是每次先找到一个未访问的最近的点，然后把这个点作为跳板，尝试缩短到其他未访问点的距离（已经访问过的点，已经是最短距离，不能再做更新）。重复n次相同操作。
算法流程：

设 $d i s [n]$ 为源点S到各个点的距离， $d i s [S]$ 设为0，其余点设为inf，把源点设置为已访问
在dis数组中找一个最小的未访问的点k作为跳板，去更新其他点

练习题

M. Travel 2019西安邀请赛（二分 +BFS）

链接：https://www.jisuanke.com/contest/2625/challenges

题意：给定一个连通图，每条边带有边权。有一架飞船每升一级时，花费 c 元，可以增长 d 的飞行距离，增加 e 个通行证，通行证数量大于 0 且飞行距离大于等于一条边的长度时，才能通过这条边。飞船初始为 0 级，飞行距离为 0，通行证数量为 0 。问飞船从 1 飞到 n 至少需要花费多少钱？

思路：

可以发现升的级数有一个临界点，过了这个临界点之后，就都是可行的了。因此可以二分答案
二分升级次数。check 时，需要满足边权<=mid*d，也就是将大的边权抛弃，看从 1 走到 n 最少需要多少条边。因此从 1 开始跑一下最短路，然后判断 $d i s [n]$ 与 $mid\times e$ 的大小即可。

#include <bits/stdc++.h>
#define fi first
#define se second
#define ll long long
#define int ll
using namespace std;
const int maxn=1e5+5;
const ll inf=9e18;
int n,m;
int c,d,e;
int dis[maxn];
vector<pair<int,int> > edges[maxn];
bool check(int mid)
{
    queue<int> q;
    for(int i=1;i<=n;++i) dis[i]=inf;
    dis[1]=0;
    q.push(1);
    while(!q.empty())
    {
    	int u=q.front();
    	q.pop();
    	for(auto x: edges[u])
    	{
    		int v=x.fi,w=x.se;
    		if(mid*d<w) continue;
    		if(dis[v]>dis[u]+1)
    		{
    			dis[v]=dis[u]+1;
    			q.push(v);
			}
		}
	}
	return dis[n]<=mid*e;
}
main()
{
    scanf("%lld%lld",&n,&m);
    scanf("%lld%lld%lld",&c,&d,&e);
    for(int i=1; i<=m; ++i)
    {
        int u,v,w;
        scanf("%lld%lld%lld",&u,&v,&w);
        edges[u].push_back({v,w});
        edges[v].push_back({u,w});
    }
    int L=0,R=1e6;
    while(L<R)
    {
        int mid=(L+R)>>1;
        if(check(mid)) R=mid;
        else L=mid+1;
    }
    printf("%lld\n",1ll*c*L);
}

L2-001 紧急救援（Dijkstra 求最短路路径数）

链接

题意：给定一个连通图，给定起点和终点，给定边权和点权。求最短路径的数量，同时满足点权和最大、点权和最大的最短路方案。输出路径数、最大点权和、方案。

思路：

首先最短路用 dis 数组记录，最短路的数量用 path 数组记录
点权用 pw 记录，最大点权用 mxpw记录。
方案用 pre 数组记录。
当 dis[v]>dis[u]+w 时，此时最短路由 u 走到 v ，那么路径数不变：path[v]=path[u]，最短路更新：dis[v]=dis[u]+w。点权和更新：mxpw[v]=mxpw[u]+pw[v]。路径方案更新：pre[v]=u
当 dis[v] ==dis[u]+w 时，此时表明 v 原本已经有路可以更新，因此路径数 path[v]+=path[u]。如果点权可以更新，那么同时更新路径。

#include <bits/stdc++.h>
#define fi first
#define se second
#define ll long long
using namespace std;
const int maxn=500+10,inf=2e9;

int n,m,s,t;
vector<pair<int,int> > e[maxn];
int pw[maxn],mxpw[maxn],dis[maxn],pre[maxn],path[maxn];
int visit[maxn];

void dijkstra()
{
    for(int i=1; i<=n; ++i) dis[i]=inf;
    dis[s]=0;
    mxpw[s]=pw[s];
    path[s]=1;
    pre[s]=-1;
    priority_queue<pair<int,int> > pq;
    pq.push({0,s});
    while(!pq.empty())
    {
        auto t=pq.top();
        pq.pop();
        int u=t.se;
        if(visit[u]) continue;
        visit[u]=1;
        for(auto x: e[u])
        {
            int v=x.fi,w=x.se;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                path[v]=path[u];
                mxpw[v]=mxpw[u]+pw[v];
                pre[v]=u;
                pq.push({-dis[v],v});
            }
            else if(dis[v]==dis[u]+w)
            {
                path[v]+=path[u];
                if(mxpw[v]<mxpw[u]+pw[v])
                {
                    mxpw[v]=mxpw[u]+pw[v];
                    pre[v]=u;
                }
            }
        }
    }
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&s,&t);
    s++,t++;
    for(int i=1; i<=n; ++i) scanf("%d",&pw[i]);
    for(int i=1; i<=m; ++i)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        u++,v++;
        e[u].push_back({v,w});
        e[v].push_back({u,w});
    }
    dijkstra();
    printf("%d %d\n",path[t],mxpw[t]);
    vector<int> ans;
    for(int i=t; i!=-1; i=pre[i])
        ans.push_back(i);
    for(int i=ans.size()-1; i>=0; --i)
        printf("%d%c",ans[i]-1,i==0?'\n':' ');
    return 0;
}

一个人的旅行 HDU - 2066 （最短路枚举起点）

链接：http://acm.hdu.edu.cn/showproblem.php?pid=2066

题意：有一张无向图，点表示城市，边权表示两个城市之间花费的时间。草儿家有 s 个相邻的城市，有 d 个想去的城市。问草儿最少花费多少时间到某个想去的城市游玩。

思路：枚举每个相邻的城市，统计答案最小值

#include <bits/stdc++.h>
#define fi first
#define se second
#define ll long long
using namespace std;
const int maxn=1000+10,maxm=2000+10,inf=1e9;

int n,m,s,d,start[maxn],dest[maxn];
int dis[maxn],visit[maxn];
int head[maxn],ecnt;
struct Edge
{
    int nxt,to,w;
} edges[maxm];
void add(int u,int v,int w)
{
    edges[++ecnt]= {head[u],v,w};
    head[u]=ecnt;
}

void dijkstra(int s)
{
    for(int i=1; i<=n; ++i)
        dis[i]=inf,visit[i]=0;
    dis[s]=0;
    priority_queue<pair<int,int> > pq;
    pq.push({0,s});
    while(!pq.empty())
    {
        auto t=pq.top();
        pq.pop();
        int u=t.se;
        if(visit[u]) continue;
        visit[u]=1;
        for(int i=head[u]; i!=-1; i=edges[i].nxt)
        {
            int v=edges[i].to,w=edges[i].w;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                pq.push({-dis[v],v});
            }
        }
    }
}

int main()
{
    while(~scanf("%d%d%d",&m,&s,&d))
    {
        memset(head,-1,sizeof(head));
        ecnt=0;
        n=0;
        for(int i=1; i<=m; ++i)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
            n=max({u,v,n});
        }
        for(int i=1; i<=s; ++i) scanf("%d",&start[i]);
        for(int i=1; i<=d; ++i) scanf("%d",&dest[i]);

        int ans=inf;
        for(int i=1; i<=s; ++i)
        {
            dijkstra(start[i]);
            for(int j=1; j<=d; ++j)
                ans=min(ans,dis[dest[j]]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

find the mincost route HDU - 1599（Floyd 无向图找最小环）

链接：http://acm.hdu.edu.cn/showproblem.php?pid=1599

题意：找一个至少经过 3 个点最小环
思路：在 floyd 算法中 dis[k][x][y] 表示 x 和 y 通过节点 1 ~ k 能够形成的最短路。所以需要在每次枚举 k ，用 k 更新 x 和 y 之间的距离之前，计算通过 k 是否能够构成一个环，取一个最小值即可。

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=100+5,mod=1e9+7;
const int inf=1e8;
int n,m;
int mp[maxn][maxn],dis[maxn][maxn];
int floyd()
{
    int ans=inf;
    for(int k=1; k<=n; ++k)
    {
        for(int i=1; i<k; ++i)
            for(int j=i+1; j<k; ++j)
                ans=min(ans,dis[i][j]+mp[i][k]+mp[k][j]);
        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]);
    }
    return ans==inf?-1:ans;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1; i<=n; ++i)
            for(int j=1; j<=n; ++j)
                mp[i][j]=inf;
        for(int i=1; i<=m; ++i)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            if(mp[u][v]>w) mp[u][v]=mp[v][u]=w;
        }
        for(int i=1; i<=n; ++i) mp[i][i]=0;
        memcpy(dis,mp,sizeof(mp));
        int ans=floyd();
        if(ans==-1) printf("It's impossible.\n");
        else printf("%d\n",ans);
    }
    return 0;
}

Wormholes POJ - 3259（SPFA 判负环）

链接：http://poj.org/problem?id=3259

题意：有n个村庄、m条路径、w个虫洞。每条路径连接两个村庄，移动会花费时间。虫洞只能单向传递，会让时光回溯t秒。问能够通过一些路径和虫洞，从起点出发后回到起点，并实现了穿越到出发以前的时空？
思路：用 Bellman - Ford 或者 spfa 判断是否存在负环

Bellman - Ford写法

#include <cstdio>
#include <cstring>
#define ll long long
using namespace std;
const int maxn=3000+5,mod=1e9+7;
const int inf=100000;

int t,n,m,k,cnt;
int dis[550];

struct Edge
{
	int u,v,w;
}edge[maxn<<1];

void add(int u,int v,int w)
{
	edge[++cnt].u=u;
	edge[cnt].v=v;
	edge[cnt].w=w;
} 

bool Bellman_Ford()
{
	for(int i=1;i<=n;++i)
		dis[i]=inf;
	dis[1]=0;
	
	for(int i=1;i<=n-1;++i)
	{
		bool valid=false;//判断有没有松弛操作 
		for(int j=1;j<=cnt;++j)
		{
			int u=edge[j].u,v=edge[j].v,w=edge[j].w;
			if(dis[u]>dis[v]+w)
			{
				dis[u]=dis[v]+w;
				valid=true;
			}			
		}
		if(!valid)
			break;
	}
	
	bool valid=false;//默认没有负权环 
	for(int i=1;i<=cnt;++i)
	{
		int u=edge[i].u,v=edge[i].v,w=edge[i].w;
		if(dis[u]>dis[v]+w)
		{
			valid=true;
			break;
		}
	}
	return valid;
}

int main()
{
	scanf("%d",&t);
	while(t--)
	{
		memset(edge,0,sizeof(edge));
		cnt=0;	
		scanf("%d%d%d",&n,&m,&k);
		int u,v,w;
		for(int i=1;i<=m;++i)
		{
			scanf("%d%d%d",&u,&v,&w);
			add(u,v,w);
			add(v,u,w);
		}
		for(int i=1;i<=k;++i)
		{
			scanf("%d%d%d",&u,&v,&w);
			add(u,v,-w);		
		}
		if(Bellman_Ford())
			puts("YES");
		else	
			puts("NO");
	}
	return 0;
}

SPFA写法

#include <cstdio>
#include <queue>
#include <cstring>
#define ll long long
using namespace std;
const int maxn=500+10,maxm=5500+10,inf=2e9;

int t,n,m,k;
int head[maxn],ecnt;
struct Edge
{
    int w,to,nxt;
} edges[maxm];
void add(int u,int v,int w)
{
    edges[++ecnt].w=w;
    edges[ecnt].to=v;
    edges[ecnt].nxt=head[u];
    head[u]=ecnt;
}
int visit[maxn],num[maxn],dis[maxn];
bool spfa(int s)
{
    for(int i=1; i<=n; ++i)
        dis[i]=inf,visit[i]=0,num[i]=0;
    dis[s]=0;
    queue<int> q;
    q.push(s);
    visit[s]=1;
    num[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        visit[u]=0;
        for(int i=head[u]; i!=-1; i=edges[i].nxt)
        {
            int v=edges[i].to,w=edges[i].w;
            if(dis[u]+w<dis[v])
            {
                dis[v]=dis[u]+w;
                if(!visit[v])
                {
                    visit[v]=1;
                    q.push(v);
                    num[v]++;
                    if(num[v]==n) return 1;
                }
            }
        }
    }
    return 0;
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset(head,-1,sizeof(head));
        ecnt=-1;
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1; i<=m; ++i)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
        }
        for(int i=1; i<=k; ++i)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,-w);
        }
        bool ok=spfa(1);
        puts(ok?"YES":"NO");
    }
    return 0;
}

Cheng Yu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
最短路习题

最短路习题L2-001 紧急救援（Dijkstra 求最短路路径数）一个人的旅行 HDU - 2066 （最短路枚举起点）find the mincost route HDU - 1599（Floyd 无向图找最小环）Wormholes POJ - 3259（SPFA 判负环）L2-001 紧急救援（Dijkstra 求最短路路径数）链接题意：给定一个连通图，给定起点和终点，给定边权和点权。求最短路径的数量，同时满足点权和最大、点权和最大的最短路方案。输出路径数、最大点权和、方案。思路：首先
复制链接

扫一扫