YBTOJ 最短路径专项

于 2022-08-30 15:16:40 发布
阅读量242 收藏
点赞数 2
分类专栏： 题解 文章标签： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60137414/article/details/126600424
版权

floyd:

时间复杂度O(n^{3})，注意k在最外层，注意初始值f[i][i]=0，其余为inf

for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
    f[i][j]=min(f[i][j],f[i][k]+f[k][j]);

Bellman-Ford:

对整个图中每一条边不断进行松弛，直到某一轮没能成功进行改变，松弛停止。由于每一轮操作一定会确定最短路上至少一条边，所以时间复杂度最大O(nm)

对于最短路存在的图，松弛操作最多只会执行 n-1 轮，因此如果第 n 轮循环时仍然存在能松弛的边，说明从 s 点出发，能够抵达负环

如果需要判断整个图上是否存在负环，建立一个超级源点，向图上每个节点连一条权值为 0 的边，然后以超级源点为起点执行。

由于只有上一次被松弛的结点，所连接的边，才有可能引起下一次的松弛操作，那么我们用队列来维护“哪些结点可能会引起松弛操作”，就能只访问必要的边--->SPFA

void SPFA()
{
    q.push(s);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();vis[u]=0;
		for(int i=head[u];i;i=e[i].next)
		{
			int v=e[i].to;
			if(dis[v]>dis[u]+e[i].w)
			{
				dis[v]=dis[u]+e[i].w;
				if(!vis[v]) vis[v]=1,q.push(v);
			}
		}
	}
}

Dijkstra

最短路 - OI Wiki

单源最短路

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=100010;
int n,m,s,dis[N],tot,head[N];
bool vis[N];
struct edge{int to,next,w;}e[N<<1];
struct node
{
	int dis,pos;
	bool operator<(const node &x)const
	{ return x.dis<dis; }
};
priority_queue<node>q;
void Dij()
{
	dis[s]=0;
	q.push((node){0,s});
	while(!q.empty())
	{
		node tmp=q.top();
		q.pop();
		int u=tmp.pos;
		if(vis[u]) continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].next)
		{
			int v=e[i].to;
			if(dis[v]>dis[u]+e[i].w)
			{
				dis[v]=dis[u]+e[i].w;
				if(!vis[v]) q.push((node){dis[v],v});
			}
		}
	}
}
int read()
{
	int x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
void add_edge(int u,int v,int w)
{
	e[++tot].to=v;
	e[tot].w=w;
	e[tot].next=head[u];
	head[u]=tot;
}
signed main()
{
	memset(dis,0x3f3f3f,sizeof dis);
	n=read(),m=read(),s=read();
	for(int i=1;i<=m;i++)
	{
		int u=read();
		int v=read();
		int w=read();
		add_edge(u,v,w);
	}
	Dij();
	for(int i=1;i<=n;i++) printf("%d ",dis[i]);
	return 0;
}

最优贸易

由于题目明确了点可以随便经过但是贸易只能进行一次，所以考虑把强连通的点直接缩到一起来降低复杂度。接下来就是在DAG上进行DP，首先我们找到每个强连通分量的最大值和最小值，因为路径必须从点1开始到点n结束，所以topo中一个强连通分量的最小值可以由它前面的从点1过来的路径上的最小值替代。code:

#include<bits/stdc++.h>
using namespace std;
const int M=500010;
int n,m,into[M],out[M],head[M],cnt;
int dfn[M],low[M],scc_num[M],scc_cnt,vis[M],s[M],top,f[M];
int minn[M],maxx[M],a[M],x[M],y[M];
struct edge
{ int to,next; } e[M];

void add_edge(int u,int v)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}

void tarjan(int u)
{
	dfn[u]=low[u]=++cnt;
	vis[u]=1;
	s[++top]=u;
	for(int i=head[u]; i; i=e[i].next)
	{
		int v=e[i].to;
		if(!dfn[v])
		{
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(vis[v]) low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u])
	{
		scc_cnt++;
		while(s[top+1]!=u)
		{
			scc_num[s[top]]=scc_cnt;
			minn[scc_cnt]=min(minn[scc_cnt],a[s[top]]);
			maxx[scc_cnt]=max(maxx[scc_cnt],a[s[top]]);
			vis[s[top--]]=0;
		}
	}
}

void work(int tag)
{
	queue<int>q;
	q.push(scc_num[tag]);
	f[scc_num[tag]]=max(f[scc_num[tag]],maxx[scc_num[tag]]-minn[scc_num[tag]]);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=head[u]; i; i=e[i].next)
		{
			int v=e[i].to;
			into[v]--;
			minn[v]=min(minn[v],minn[u]);
			f[v]=max(max(f[u],maxx[v]-minn[v]),f[v]);
			if(!into[v]) q.push(v);
		}
	}
}

int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1; i<=n; i++) scanf("%d",&a[i]);
	for(int i=1; i<=m; i++)
	{
		int u,v,dic;
		scanf("%d%d%d",&u,&v,&dic);
		if(dic==1)
		{
			add_edge(u,v);
			x[cnt]=u;
			y[cnt]=v;
		}
		if(dic==2)
		{
			add_edge(u,v);
			add_edge(v,u);
		}
	}
	m=cnt;
	memset(minn,1e6,sizeof minn);
	memset(maxx,-1e6,sizeof maxx);
	for(int i=1;i<=n;i++) if(!dfn[i]) tarjan(i);
	memset(head,0,sizeof head);
	memset(e,0,sizeof e);
	for(int i=1;i<=m;i++)
	{
		if(scc_num[x[i]]!=scc_num[y[i]])
		{
			add_edge(scc_num[x[i]],scc_num[y[i]]);
			into[scc_num[y[i]]]++;
		}
	}
	work(1);
	printf("%d",f[scc_num[n]]);
	return 0;
}

DFS做法：

#include<bits/stdc++.h>
using namespace std;
const int M=100010;
vector<int>q[M];
int n,m,f[M],minn[M],a[M];
void dfs(int x,int mn,int last)
{
	int flag=1;
	mn=min(a[x],mn);
	if (minn[x]>mn)
	{
		minn[x]=mn;
		flag=0;
	}
	int maxx=max(f[last],a[x]-mn);
	if (f[x]<maxx)
	{
		f[x]=maxx;
		flag=0;
	}
	if(flag) return;
	for(int i=0;i<q[x].size();i++) dfs(q[x][i],mn,x);
}

int main()
{
	scanf("%d%d",&n,&m);
	memset(minn,0x3f3f3f,sizeof minn);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=m;i++)
	{
		int u,v,dic;
		scanf("%d%d%d",&u,&v,&dic);
		q[u].push_back(v);
		if(dic==2) q[v].push_back(u);
	}
	dfs(1,1e9,0);
	printf("%d",f[n]);
	return 0;
}

90182sidalao的做法：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=100010; 
int n,m,val[N],gap[N],f[N];
vector<int>e[N];
vector<int>::iterator p;
int read()
{
	int x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
signed main()
{
	n=read(),m=read();
	for(int i=1;i<=n;i++) val[i]=read();
	for(int i=1;i<=m;i++)
	{
		int u=read();
		int v=read();
		int op=read();
		e[v].push_back(u);
		if(op==2) e[u].push_back(v);
	}
	for(int i=1;i<=n;i++)
	{
		for(p=e[i].begin();p!=e[i].end();p++)
		{
			gap[i]=max(gap[i],val[i]-val[*p]+gap[*p]);
			f[i]=max(f[i],max(f[*p],gap[*p]));
		}
	}
	printf("%lld",f[n]);
	return 0;
}

明明代码差几十行时间却差不多 :-D

汽车加油

还有什么可说的呢。。。就建边极为鬼畜qwq

#include<bits/stdc++.h>
using namespace std;
int n,m,k,a[210][210],id[210][210],ans=1e9;
int top,cnt=-1,head[5000010],jud[5000010],dis[5000010];
struct edge
{ int next,to,w; } e[5000010];
queue<int>q;
void add_edge(int u,int v,int w)
{
	e[++cnt].next=head[u];
	e[cnt].to=v;
	e[cnt].w=w;
	head[u]=cnt;
}
void work()
{
	memset(dis,0x3f3f3f,sizeof dis);
	int u,v;
	dis[1]=0;
	q.push(1);
	while(!q.empty())
	{
		u=q.front();
		q.pop();
		jud[u]=0;
		for(int i=head[u];i;i=e[i].next)
		{
			v=e[i].to;
			if(dis[v]>dis[u]+e[i].w)
			{
				dis[v]=dis[u]+e[i].w;
				if(!jud[v])
				{
					jud[v]=1;
					q.push(v);
				}
			}
		}
	}
}
int main()
{
	int A,b,c;
	memset(head,-1,sizeof head);
	scanf("%d%d%d%d%d",&n,&k,&A,&b,&c);
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	{
		id[i][j]=++top;
		scanf("%d",&a[i][j]);
	}
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	{
		if(a[i][j])
		{
			int aa=id[i][j],bb=id[i][j]+n*n;
			if(j!=n) add_edge(aa,bb+1,0);
			if(j!=1) add_edge(aa,bb-1,b);
			if(i!=1) add_edge(aa,bb-n,b);
			if(i!=n) add_edge(aa,bb+n,0);
			for(int d=1;d<=k;d++) add_edge(aa+d*n*n,aa,A);
			continue;
		}
		for(int d=1;d<=k;d++)
		{
			int aa=id[i][j]+(d-1)*n*n;
			int bb=id[i][j]+d*n*n;
			if(j!=n) add_edge(aa,bb+1,0);
			if(j!=1) add_edge(aa,bb-1,b);
			if(i!=1) add_edge(aa,bb-n,b);
			if(i!=n) add_edge(aa,bb+n,0);
			add_edge(aa,id[i][j],c+A);
			if(d==k) add_edge(bb,id[i][j],c+A);
		}
	}
	work();
	for(int i=0;i<=k;i++) ans=min(ans,dis[(i+1)*n*n]);
	printf("%d",ans);
	return 0;
}

xiyuping24
关注
专栏目录
ybtoj【数学基础】1章4题【最短路径】
zhanglili1597895的博客
06-19 262
最短路径 题目 解析 点太多，考虑离散化 离散化完发现可以使用O(23t3log⁡n)O(2^3t^3\log n)O(23t3logn)的矩阵乘法加速，改一下式子就好了 zi,j=min(xi,k+yk,j)(1<=k<=tot)z_{i,j}=min(x_{i,k}+y_{k,j})(1<=k<=tot)zi,j​=min(xi,k​+yk,j​)(1<=k<=tot) code: #include<cstdio> #include<algori
YbtOJ 修建道路（最短路径）
struct_GS的博客
09-22 598
目录： 前置知识 题目描述 解题思路 AC 代码 前置知识： 最短路径（Dijkstra）、二分算法、 链式前向星 题目描述： 大概意思就是：求一条最短路径，其中 k 条路免费，求最小的值。 解题思路： 这道题给我的感觉就是——不好做，像最短路径，又不像最短路径。 很明显，这 k 条免费的路是个麻烦——不能直接用最短路。 暴力免费的路的条数肯定过不了，数据超过了 200 也不能...
【ybtoj高效进阶5-5-2】最短路径
天空之心
08-08 134
【ybtoj高效进阶5-5-2】最短路径 题目大意： 给你一个无项有权图，问你从第 0 号点经过每一个点走到第 n-1 个点的最短路径的权值是多少？ 思路： (1)：深搜枚举全排列，一个一个暴力去试，时间复杂度O(n∗n!)O(n*n!)O(n∗n!) 不死也残，无法通过 然后一看好像是状压DP 我们设f[i][j]f[i][j]f[i][j]表示此时路径经过点的状态为 i ，此时在处理的点为 j ，我们将 i 用二进制表示，i 从低到高的第 x 位表示第 x 个点，0为没经过，1为已经走过。 我们有f[i
【ybtoj 高效进阶 3.3】 【最短路径】 单元最短路径
Y的博客
05-05 156
【ybtoj 高效进阶 3.3】 【最短路径】 单元最短路径 题目 解题思路 Dijkstra每次找出最短的边加入集合 更新其他点到起点的距离 但是时间会爆 用堆优化直接取出最小 代码 #include <iostream> #include <cstring> #include <cstdio> #include <queue> #define yty pair<int, int> using namespace std; priorit
ybtoj【动态规划】5章2题【最短路径】
zhanglili1597895的博客
07-07 234
最短路径 题目 解析 发现n≤20n\leq 20n≤20，不妨考虑复杂度为O(n2n)O(n2^n)O(n2n)的算法 发现每个点只有两种状态，考虑二进制状压，然后设dpi,jdp_{i,j}dpi,j​为状态j(i=popcount(j)i=popcount(j)i=popcount(j))(popcount即二进制下1的个数)，枚举状态转移即可 code: #include<cstdio> #include<cstring> using namespace std; inl
【Ybtoj 第25章例5】最短路径【矩阵快速幂】
在人间贩卖声音
08-13 203
解题思路 考虑DP，设f[i][j][k]f[i][j][k]f[i][j][k]表示从i到j走k条路的最短路径长度，易得转移方程： f[i][j][k]=min(f[i][t][k−1]+f[t][j][1])f[i][j][k]=min(f[i][t][k-1]+f[t][j][1])f[i][j][k]=min(f[i][t][k−1]+f[t][j][1])。 因为在转移时kkk只与k−1k-1k−1有关，所以可以化简掉第三维f[i][j]=min(f[i][t]+f[t][j])f[i][j...
YbtOJ 最短路径课堂过关 例4 汽车加油【dijkstra】
JA_yichao欢迎你 cnblogs账号：https://www.cnblogs.com/mayichao/
05-04 191
思路 这道题我们可以把不同的情况分类讨论一下： 如果当前点有油而且油没满，那么就判断一下加油的情况 如果当前点没油而且油没满，那么就判断一下建油加油的情况 如果当前还可以走，那么就尝试往4个方向拓展的情况。 代码 #include<iostream> #include<cstring> #include<cstdio> #include<cmath> #include<queue> using namespace std; long long ..
《ybtoj高效进阶》第五部分第五章例题2 最短路径
SSL_WCR
05-14 168
题目大意 给n个点，从0~n-1编号，再给出两两之间最短路径长度（必有路），求不重不漏的经过每个点（起点000，终点n−1n-1n−1）的最短路径长度。 思路 显然装压dp。设fx,yf_{x,y}fx,y​为终点x，点遍历状态为y（二进制下1为走过，0反之）,显然有f0,1=0f_{0,1}=0f0,1​=0，剩余部分方程为fx,y=min(fz,yxor(2i)+disx,z)(0<=y<2n,0<=x<n且x在y的状态为走过,0<=k<n且该位合法f_{x,y}=m
【矩阵乘法】最短路径
blog
12-04 692
给出一个无向图，起点s ，终点e ，t 条边和一个正整数n ，求从 s 到 e 走过 n 条边的最短路径长度。
YbtOJ 最短路径课堂过关 例1 单源最短路径【dijkstra】【堆优化】
JA_yichao欢迎你 cnblogs账号：https://www.cnblogs.com/mayichao/
04-17 226
思路 这道题是最短路径模板题，不过需要dij加上小根堆优化才能过。 用邻接表实现。 代码 #include<algorithm> #include<iostream> #include<cstdio> #include<queue> #define lzh pair<int,int> using namespace std; int dis[300010],v[300010]; priority_queue<lzh> q; int ..
《ybtoj高效进阶》第六部分第一章例题5 最短路径
SSL_WCR
05-22 248
题目大意 给出一个无向图，起点sss，终点eee，ttt条边和一个正整数nnn，求从sss到eee走过最多nnn条边的最短路径长度。 思路 节点离散化后抽象成邻接矩阵，更新公式为fi,j=min(fi,k+fk,j)f_{i,j}=min(f_{i,k}+f_{k,j})fi,j​=min(fi,k​+fk,j​)，发现类似于矩阵快速幂，于是就这么愉快地结束了…… #include<iostream> #include<cstdio> #include<algorithm&gt
【模拟】最少移动
Maple的博客
11-01 203
给一个数组，然后求经过多少次操作（相邻俩数一加一减），使得全部数相等
【YBTOJ】耗费体力
ha
12-24 388
思路： 设fif_ifi​表示到第i个人要用的最小花费，然后从前k个转移过来，用单调队列来维护 codecodecode #include<iostream> #include<cstdio> using namespace std; int n, t; int a[1000100], f[1000100]; int q[1000100]; int main() { scanf("%d", &n); for(int i=1; i<=n; i++) s..
划分数列【Ybtoj】
Maple的博客
12-26 334
将一个数列划分成若干段，每段保证单调不降或不升，求最短划分成多少段
栈和递归3--递归
weixin_43203735的博客
09-08 248
递归 算法思想 ​ 递归（Recurrence）是计算机、数学、运筹等领域经常使用的最强大的解决问题的方法之一。他用一种简单的方式来解决那些用其他方法解起来可能很复杂的问题。 ​ 递归的基本思想是把一个问题划分为一个或多个规模更小的子问题。，然后用相同的方法解规模更小的子问题。注意，这里的子问题应该与原问题保持相同类型。 递归算法的设计： 1、找到问题的初始条件(递归入口)，即当问题规模n小到某一个值时，该问题变得简单，能够直接求解。 2、设计一个策略，将一个问题划分为一个或多个一步步接近递
【ybtoj】数独游戏
下一个路口
06-12 265
数独游戏 题目描述 数独是一种传统益智游戏，你需要把99的数独补充完整，使得图中每行、每列、每个33的九宫格内数字1~9均恰好出现一次。 请编写一个程序填写数独。 输入格式 输入包含多组测试用例。 每个测试用例占一行，包含81个字符，表达数独的81个格内数据（顺序总体由上到下，同行由左到右）。 每个字符都是一个数字或一个 .（表示尚未填充）。 您可以假设输入中的每一个谜题都只有一个解决方案。 文件结尾处包含单词 end 的单行，表示输入结束。 输出格式 每个测试用例，输出一行数据，表示填充完全后的数独。
YbtOJ 躲避拥挤（并查集）
struct_GS的博客
08-13 517
目录： 前置知识 并查集（路径压缩），快速排序（sort），结构体 题目描述 样例与数据范围 解题思路 前置知识： 并查集（路径压缩），快速排序（sort），结构体 题目描述： 样例与数据范围： 解题思路： 在并查集的专题里，当然是用并查集啦！ 刚开始的时候，小编还以为是用搜索的（你看这个题，他多像搜索啊），再读一读题目，n 个点，m 条边，这很明显是个图论题啊（废话，并查集不就是图论...
YBTOJ：数列方案（组合数学）
BUG_Creater_jie的博客
07-25 230
文章目录题目描述解析代码 题目描述 解析 如果它不取等，那就和方程的解这道题一样了，但有了等号就很头疼 如何把等号去掉呢？ 定义B i =A i +iB~i~=A~i~+iB i =A i +i那么我们就可以得到：0<B 1 <B 2 <...<B m <=m+n0<B~1~<B~2~<...<B~m~<=m
YbtOJ C. 钻石守卫【图论】【数学】
qq_35786326的博客
10-26 305
.
YBTOJ：彩色圆环
BUG_Creater_jie的博客
09-13 165
文章目录前言题目描述InputOutputSample InputSample Output解析代码 前言 尽信书，则不如无书 题目描述 Input 仅有一行，该行给出依次两个正整数N, M，分别表示宝石的个数和宝石在变化时可能变成的颜色种类数。 Output 应仅有一行，该行给出一个实数E®，表示圆环的“美观程度”的期望值。 Sample Input 8 1 Sample Output 8.00000 解析 期望dp做的太少了，这题整了巨长时间，慢慢来吧qwq 设计dp不难，枚举上一个同色块即可，关
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xiyuping24

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

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

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

打赏作者

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

抵扣说明：

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

余额充值