最短路练习

已于 2022-03-13 11:45:34 修改
阅读量157 收藏
点赞数
分类专栏： 图论 文章标签： 算法
于 2021-10-10 10:22:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cosx_/article/details/120683043
版权

P1629 邮递员送信
题意：
n n n 个点， m m m 条边的有向图，每条边花费时间 w w w，注意边是单向的，每次从 1 1 1 出发到达 2 2 2 ，返回 1 1 1 ，出发到 3 3 3 ，返回 1 1 1，…直至重复到 n n n
求结束时的最小时间花费
思路：
最暴力的算法， F l o y e d Floyed Floyed 算法求全源最短路，显然会 T L E TLE TLE。
然后考虑跑 n n n 遍 D i j k s t r a Dijkstra Dijkstra，复杂度 O ( n 2 l o g n ) O(n^2logn) O(n2logn)，实测也 T T T 了
仔细分析下这个问题
每次从 1 1 1 出发到 2 , 3 , 4... n 2,3,4...n 2,3,4...n，我们跑一遍起点为 1 1 1 的最短路即可
主要是返回时间的最小花费该如何求，跑 n n n 遍 D i j k s t r a Dijkstra Dijkstra 算法实际上做了很多无用功，因为我们只需要求得 2 , 3 , 4... n 2,3,4...n 2,3,4...n 到 1 1 1 的最短路即可。
从 1 1 1 到其余点的最短路是 一对多 的形式，而从其他点到 1 1 1 是 多对一 的形式
如果能把 多对一 转化为 一对多，问题好解决了，一次 D i j k s t r a Dijkstra Dijkstra 算法就是解决这个问题的
如果我们在建原始图的同时，再建一张反向图，在原始图中每次从 2 , 3 , 4... n 2,3,4...n 2,3,4...n 点跑到 1 1 1 的最短路和在反向图中跑一遍从 1 1 1 开始的最短路实际上是等价的
code：

#include<bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int maxn = 1e3 + 9;
int n, m;
struct node
{
	int to, next, w;
}e[maxn * 200];
int head[maxn * 2], cnt;
inline void add(int x, int y, int z)
{
	e[++cnt].w = z;
	e[cnt].to = y;
	e[cnt].next = head[x];
	head[x] = cnt;
}
int dis[maxn * 2];
bool vis[maxn * 2];
void dij(int s)
{	
	memset(dis, 0x3f, sizeof(dis));
	dis[s] = 0;
	priority_queue <pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
	q.push({0, s});
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(!vis[tmp] && dis[tmp] > dis[now] + e[i].w)
			{
				dis[tmp] = dis[now] + e[i].w;
				q.push({dis[tmp], tmp});
			}
		}
	}
}
void work()
{

	cin >> n >> m;
	while(m--)
	{
		int x, y, z;
		cin >> x >> y >> z;
		add(x, y, z);
		add(y + n, x + n, z);
	}
	ll ans = 0;
	dij(1);
	for(int i = 2; i <= n; ++i)
		ans += dis[i];
	dij(1 + n);
	for(int i = 2 + n; i <= n * 2; ++i)
		ans += dis[i];
	cout << ans << endl;
	
}

int main()
{
	ios::sync_with_stdio(0);
	work();
	return 0;
}

P1119 灾后重建
题意：
n n n 个点，第 i i i 个点在 t i t_i ti​ 时间后才可以到达， m m m 条边，表示 x x x 到 y y y 的路径花费 w w w，不存在重边， q q q 个询问，查询 x x x 到 y y y 的最短路，不存在则输出 − 1 -1 −1。
n < = 200 ,   m < = n ∗ ( n − 1 ) / 2 ,   q < = 50000 n<=200, \ m<=n*(n-1)/2, \ q<=50000 n<=200, m<=n∗(n−1)/2, q<=50000
思路：
正向加点问最短路，正好符合 f l o y d floyd floyd 算法枚举中转点 k k k ，按时间递增顺序加入的点，当作中转点 k k k 更新最短路即可

题目数据范围比较小
最短路算法可以考虑 F l o y e d Floyed Floyed 算法
查询时间保证了是单增的
每次把重建好的点当作中转点，更新最短路
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 2e2 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
ll n, m;
int dis[maxn][maxn];
int t[maxn];
void work()
{
	cin >> n >> m;
	for(int i = 0; i < n; ++i) cin >> t[i];
	for(int i = 0; i < n; ++i)
		for(int j = 0; j < n; ++j)
			dis[i][j] = inf;
	for(int i = 0; i < n; ++i) dis[i][i] = 0;
	for(int i = 0; i < m; ++i)
	{
		int x, y, z;cin >> x >> y >> z;
		dis[x][y] = dis[y][x] = z;
	}
	int q;cin >> q;
	int now = 0;
	while(q--)
	{
		int l, r, z;cin >> l >> r >> z;
		while(t[now] <= z && now < n)
		{
			for(int i = 0; i < n; ++i)
				for(int j = 0; j < n; ++j) if(dis[i][j] > dis[i][now] + dis[now][j])
					dis[i][j] = dis[i][now] + dis[now][j];
			++now;
		}
		if(t[l] > z || t[r] > z) cout << -1 << endl;
		else if(dis[l][r] == inf) cout << -1 << endl;
		else cout << dis[l][r] << endl;
	}
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

B. Greg and Graph
题意:
每次删去一个点，求当前删去该点之前的所有边的最小权值和。
思路：
每次删去一个点，直到把所有点都删尽。倒过来就相当于每次加入一个点，求加入该点后所有存在边的最小权值和，与 f l o y d floyd floyd 枚举中转点求最短路一致

P1522 [USACO2.4]牛的旅行 Cow Tours
题意：
n 个点的坐标，其中至少有两个连通块，要求在两个连通块中加一条边，然后使得新连通块的任意两个点的最短路的最大值最小。输出新连通块中的值最大的最短路，当然，是最小化后的。
思路：
因为存在连通块，所以我们可以先对连通块进行染色，进行区分。
最短路的最大值会怎么得到？
两个连通块本身的最短路的最大值，以及新连通块的最短路的最大值，三个取最大
那么如何来快速求得新连通块中最短路的最大值？
每次是连接两个连通块中的两个点，如果我们知道这两个点，分别在自己的连通块中，与其他点的最短路的最大值，我们就可以直接求得新连通块的最大值（两个点在自己连通块最短路的最大值+两点之间的距离）。因此，我们求一下每个点在自己连通块中与其他点最短路的最大值。到这可以发现，求出来每个点在自己连通块的与其他点的最短路的最大值，我们可以直接用这个最大值更新每个连通块的最大值。

步骤

  1. 先用 D F S DFS DFS 对连通块进行染色
  2. 用 F l o y e d Floyed Floyed 算法求得全源最短路
  3. 计算每个连通块中，每个点到其他点的 最短路 的最大值，以及连通块中所有最短路的最大值。
  4. 最后是找答案：对任意两个点，先判断是否同一个连通块。如果不是，考虑加入一条边，变成一个新的连通块。可以直接计算出通过这条边的最短路的最大值。 需要注意的是，通过这条边的最短路的最大值不一定是新连通块的所有最短路的最大值。这里需要比较三个值（j连通块 A 的所有最短路的最大值，连通块 B 的所有最短路的最大值， 加边后通过这条边的最短路的最大值），才能得到正确的新连通块的最大值。 枚举所有点对， 维护一下新连通块中最短路最大值的最小值。

code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 2e2 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double INF = 1e20;
int n, m;
char mp[maxn];
int color[maxn];// 染色 
double dis[maxn][maxn];
double x[maxn], y[maxn];
double Maxn[maxn];// 每个点到其他点最短路的最大值
double Maxm[maxn];// 每个连通块中最短路的最大值 
inline double jl(int i, int j)
{
	return sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
}
void dfs(int i, int id)
{
	color[i] = id;
	for(int j = 1; j <= n; ++j) if(!color[j] && dis[i][j] < INF)
		dfs(j, id);
}
void work()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
		cin >> x[i] >> y[i];
	for(int i = 1; i <= n; ++i)
	{
		cin >> (mp + 1);
		for(int j = 1; j <= n; ++j)
		{
			if(i == j) dis[i][j] = 0;
			else if(mp[j] == '0') dis[i][j] = INF;
			else dis[i][j] = jl(i, j);
		}
	}
// 染色 
	int id = 0;
	for(int i = 1; i <= n; ++i) if(!color[i]) 
		dfs(i, ++id);
// 求全源最短路 
	for(int k = 1; k <= n; ++k)
		for(int i = 1; i <= n; ++i)
			for(int j = 1; j <= n; ++j)
				if(dis[i][j] > dis[i][k] + dis[k][j])
					dis[i][j] = dis[i][k] + dis[k][j];
// 求出每个连通块中，每个点到其他点的最短路的最大值，以及每个连通块中最短路的最大值
	for(int i = 1; i <= n; ++i) 
	{
		Maxn[i] = 0;
		for(int j = 1; j <= n; ++j) if(dis[i][j] != INF)
			Maxn[i] = max(Maxn[i], dis[i][j]);
		Maxm[color[i]] = max(Maxm[color[i]], Maxn[i]);
	}
// 最小化答案 
	double Min = INF, Max = 0;
	for(int i = 1; i <= n; ++i)
		for(int j = i + 1; j <= n; ++j)
			if(color[i] != color[j])
			{
				Max = max({Maxm[color[i]], Maxm[color[j]], Maxn[i] + jl(i, j) + Maxn[j]});
				Min = min(Min, Max);
			}
	cout << fixed << setprecision(6) << Min << endl;
	// 只有 setprecision(6) 表示控制有效位数，加上 fixed 就变成了控制小数 
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

P1144 最短路计数
题意：
n n n 个点 m m m 条边的无向无权图，顶点 1 − n 1-n 1−n。求从顶点 1 1 1 开始，到其他每个点的最短路有几条。
输出 a n s   % 1 e 5 + 3 ans \ \% 1e5 + 3 ans %1e5+3，如果无法到达 i i i，输出 0 0 0。
思路：
迪杰斯特拉跑最短路顺便计数
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 100003;
const int inf = 0x3f3f3f3f;

int n, m;
struct node
{
	int to, next;
}e[maxn * 4];
int head[maxn], cnt;
inline void add(int x, int y)
{
	e[++cnt].to = y;
	e[cnt].next = head[x];
	head[x] = cnt;
}
int dis[maxn], ans[maxn];
bool vis[maxn];
priority_queue <pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
void work()
{
	cin >> n >> m;
	int u, v;
	for(int i = 1; i <= m; ++i)
	{
		cin >> u >> v;add(u, v);add(v, u);// 自环删不删不影响结果
	}
	for(int i = 1; i <= n; ++i)
		dis[i] = 1e9, vis[i] = 0;
	dis[1] = 0, ans[1] = 1;
	q.push({0, 1});
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(dis[tmp] > dis[now] + 1)
			{
				dis[tmp] = dis[now] + 1;
				ans[tmp] = ans[now];
				if(!vis[tmp])
				{
					q.push({dis[tmp], tmp});
				}
			}
			else if(dis[tmp] == dis[now] + 1)// 计数
				ans[tmp] = (ans[tmp] + ans[now]) % mod;
		}
	}
	for(int i = 1; i <= n; ++i)
		cout << ans[i] << endl;
} 

int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

1003 Emergency (25 分)
最短路计数升级版
题解
题意： n n n 个点， m m m 条边的图，要求从 c 1 c1 c1 到 c 2 c2 c2 的最短路的数量。每个节点有一个权值 w w w，最后输出最短路的数量以及最短路中节点权值和的最大值。
思路：
在最短路计数的基础上多维护一个权值和
这个题用spfa会比较麻烦，因为spfa算法中可能会经过一个点多次，因此在统计最短路径条数的时候需要额外用一个set进行存储和去重的工作。感觉比较难理解这个过程
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 1000000009;
const int inf = 0x3f3f3f3f;

int n, m;
struct node
{
	int to, next, w;
}e[maxn * 2];
int head[maxn], cnt;
inline void add(int x, int y, int z)
{
	e[++cnt].to = y;
	e[cnt].next = head[x];
	e[cnt].w = z;
	head[x] = cnt;
}
int dis[maxn], ans[maxn], W[maxn], res[maxn];
bool vis[maxn];
priority_queue <pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
void work()
{
	int c1, c2;
	cin >> n >> m >> c1 >> c2;
	int u, v, w;
	for(int i = 0; i < n; ++i) cin >> W[i];
	for(int i = 1; i <= m; ++i)
	{
		cin >> u >> v >> w;add(u, v, w);add(v, u, w);
	}
	for(int i = 0; i < n; ++i)
		dis[i] = 1e9, vis[i] = 0;
	dis[c1] = 0, ans[c1] = 1;
	q.push({0, c1});
	res[c1] = W[c1];// 初始化起点价值
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(dis[tmp] > dis[now] + e[i].w)
			{
				dis[tmp] = dis[now] + e[i].w;
				ans[tmp] = ans[now];
				res[tmp] = res[now] + W[tmp];
				q.push({dis[tmp], tmp});
			}
			else if(dis[tmp] == dis[now] + e[i].w)
			{
				ans[tmp] += ans[now];
				res[tmp] = max(res[tmp], res[now] + W[tmp]);
				//q.push({dis[tmp], tmp});
			}
		}
	}
	cout << ans[c2] << " " << res[c2] << endl;
} 

int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

P1462 通往奥格瑞玛的道路
题意：
n n n 个点， m m m 条边，边权为 c i c_i ci​ 代表通过这条边花费的生命值，初始生命值为 b b b。每个节点有一个权值 f i f_i fi​ 代表通过这个城市的花费。从 1 1 1 跑到 n n n，在能跑到节点 n n n 的情况下，最小化通过一个城市花费的最大值。
思路：
最小化最大值，显然二分。
注意如何特判掉输出 APK 的情况：把对花费的约束置为 inf，跑一遍dij判断是不是无法到达。
注意在 c h e c k check check 中加一个 f l a g flag flag 判断是否到达过这个思路是有问题的，因为 c h e c k check check 的 m i d mid mid 不够大，花仍然会约束路径
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e4 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int n, m, b;
int f[maxn];
ll dis[maxn];
struct Edge
{
	int to, next, w;
}e[maxn * 10];
int head[maxn], vis[maxn], cnt;
inline void add(int x, int y, int z)
{
	e[++cnt].to = y;
	e[cnt].w = z;
	e[cnt].next = head[x];
	head[x] = cnt;
}
bool check(int mid)
{
	if(f[1] > mid) return false;// 特判起点 
	priority_queue<pair<ll,int>,vector<pair<ll,int> >,greater<pair<ll,int> > > q;
	for(int i = 1; i <= n; ++i) dis[i] = inf, vis[i] = 0;
	dis[1] = 0;
	q.push({0, 1});
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int to = e[i].to;
			if(f[to] <= mid && dis[to] > dis[now] + e[i].w)
			{
				dis[to] = dis[now] + e[i].w;
				q.push({dis[to], to});	
			}
		}
	}
	if(dis[n] < b) return true;
	else return false;
}
void work()
{
	cin >> n >> m >> b;
	for(int i = 1; i <= n; ++i) cin >> f[i];
	for(int i = 1; i <= m; ++i)
	{
		int a, b, c;cin >> a >> b >> c;
		add(a, b, c);add(b, a, c);
	}
	if(!check(inf)){
		cout << "AFK" << endl;return;
	}
	int l = 0, r = 1e9;
	while(l < r)
	{
		int mid = (l + r) >> 1;
		if(check(mid)) r = mid;
		else l = mid + 1; 
	}
	cout << l << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}
__Rain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解题报告：【kuangbin带你飞】专题四 最短路练习题
繁凡さん的博客
07-10 985
最短路合集
图论基础之最短路和最小生成树
最新发布
m0_55341679的博客
10-09 501
最短路和最小生成树
最短路专题练习
zhuml123的专栏
10-23 506
一、入门难度 1、HDU 2544（一级） 【题意】 给出n个顶点m条边，以及每条边的权值为w，求1到n的最短路 【思路】 裸题 2、HDU 2066 (一级) 【题意】 因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。 【思路】 这道题其实一次Dijkstra就可以了，我们将草儿的家看做0，从草儿家到相邻镇的花费看做0，那么我们就只需要求草...
[kuangbin带你飞]专题四 最短路练习
09-12 216
A - Til the Cows Come Home  POJ - 2387  题意：t条边，n个点，求最短路。2&lt;=n&lt;=1000,1&lt;=t&lt;=2000。 题解：floyd时间复杂度O（n^3）1e9肯定超时. //Floyd，超时代码 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cst...
最短路习题集（hdu）
ljlhnick的博客
08-05 1352
下面把在杭电刷题的最短路的代码贴上 hdu 2544 点击打开链接 dijkstra算法 #include <iostream> #include <algorithm> #include <stdio.h> #include <string.h> #define N 200 #define Y 33333110 using names...
poj 1860 Currency Exchange ([kuangbin带你飞]专题四 最短路练习)
Strive
11-10 444
Description Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these curren
电学中短路练习题.doc
10-08
综上所述，这些练习题涵盖了电路的基本概念、电路连接方式、电流方向、短路现象、电路元件的工作状态、电路安全以及电路图的解读等多个核心知识点。通过解决这些问题，学生可以提升对电学基础知识的理解和应用能力。
管理运筹学试题及答案(线性规划,运输问题,动态规划,最短路最大流).pdf
09-27
管理运筹学试题及答案(线性规划,运输问题,动态规划,最短路最大流).pdf
最短路习题
Jackzhan的博客
08-13 666
有限制最短路（枚举+最短路） 分层图最短路
P6560 [SBCOI2020] 时光的流逝 （博弈，反向建图，拓扑排序
cosx_的博客
03-09 4616
洛谷P6560 [SBCOI2020] 时光的流逝 题意： 给定一个有向图（可能有环），给定起点和终点，两个人玩游戏，一人走一步，先到达终点的人赢或者先无法移动的人输 思路： 题解 因为是终点和叶子节点是必败态，这是确定的，因此我们可以倒着搞 建反图跑拓扑排序更新节点胜负态 存在环就很难搞，拓扑排序的时候是无法进入环的，那么环上的点就难以确定胜负态 更新思想有点类似于点权这个题 就是如果当前节点胜负态是确定的，就可以去更新其他节点，我们就把他 pushpushpush 到队列中，而不是按照拓扑排序的顺序来
最小环算法
cosx_的博客
11-29 2449
知乎学习链接 最小环概念： 在无向图中，最小环至少应当包含 333 个顶点。也就是说，将无向边拆分为两条有向边，以此形成的 222 顶点环，不能视作最小环，有向图则无顶点数的限制。 在图论中，一张图的最小环长度也被称为它的围长（girth）。 Floyd求无向图最小环 该算法最常使用，足以解决绝大多数无向图最小环问题。 当最外层恰好循环到 kkk 时，代表着目前所求出的最短路所含的点集为 [1,k)[1,k)[1,k)。 这时的中转点 kkk 一定不存在于 iii —> jjj 的最短路中，然后再枚举
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）
cosx_的博客
10-11 1012
7-2 芬兰木棋 (25 分) 被这题背刺了，最后才想明白wa点，想了一个小时，草了 code： #include<bits/stdc++.h> #define endl '\n' #define ll long long using namespace std; const int maxn = 1e5 + 9; const int mod = 1e9 + 7; const int inf = 0x3f3f3f3f; ll n, m; int x[maxn], y[maxn], p[maxn]
线段树优化 dijkstra
cosx_的博客
12-01 923
学习博客 P4779 【模板】单源最短路径（标准版） 学习新东西肯定先从最简单的开始，先上最短路板子题 思路： 题解博客 线段树优化 Dijkstra 我们需要支持三个操作： 修改某个点的 disdisdis 找到一个没有拿出来过的 disdisdis 最小的点 标记某个点已经被拿出来过 于是可以用线段树维护区间 disdisdis 的最小值和这个最小值对应的位置。这样子如果一个点已经被拿出来过，我们直接在线段树上把它改成 +∞+\infty+∞，这样子它之后就不会被拿出来了。 code： #inclu
欧拉回路/欧拉路径
cosx_的博客
02-26 916
搬来大佬的前置知识： 定义：从一个点出发，不重不漏的经过图中每一条边的一条路径（允许多次经过同一个点）。如果此路径的起点和终点相同，则称其为一条欧拉回路。 欧拉路径判定（是否存在）： 首先要保证连通 有向图欧拉路径：图中恰好存在 111 个点出度比入度多 111（这个点即为起点 SSS），111 个点入度比出度多 111（这个点即为终点 TTT），其余节点出度 === 入度。 有向图欧拉回路：所有点的入度 === 出度（起点 SSS 和终点 TTT 可以为任意点）。 无向图欧拉路径：图中恰好存在 222
Atcoder D. Shortest Path on a Line （最短路 + 思维，建图难想
cosx_的博客
12-02 882
D - Shortest Path on a Line 题意： 给定 nnn 点，编号从 111 到 nnn，初始图没有边，mmm 次操作，每次给定 l,r,cl,r,cl,r,c，表示编号在区间 [l,r][l,r][l,r] 任意两点之间连有一条长度为 ccc 的边，求最终图中 111 到 nnn 的最短路。 思路： 这种操作会导致 111 到 iii 的最短路 dis[i]dis[i]dis[i] 出现一个神奇的性质，dis[1]<=dis[2]<=dis[3]...<=dis[n]
floyd与传递闭包
cosx_的博客
03-09 767
在交际网络中，给定若干个元素和若干对二元关系，且关系具有传递性。通过传递性推导出尽量多的元素之间的关系的问题被成为传递闭包 建立邻接矩阵 ddd，di,j=1d_{i,j}=1di,j​=1 表示 iii 与 jjj 有关系，di,j=0d_{i,j}=0di,j​=0 表示 iii 与 jjj 没有关系。特别的，di,id_{i,i}di,i​ 始终为 111。使用 floydfloydfloyd 算法可以解决传递闭包问题： ll n, m; bool d[maxn][maxn]; void work()
ABC 237 E（无向图中的最长路问题转化为最短路问题
cosx_的博客
02-07 752
题意： 给定 nnn 点高度为 aia_iai​，初始位置为 111，求从 111 出发的最长路（经过边权的代数和最大）是多少 两个点之间的边权这样定义： 现在从 xxx 要去 yyy 如果 ax>aya_x>a_yax​>ay​，那么边权为 ax−aya_x-a_yax​−ay​ 如果 ax<aya_x<a_yax​<ay​，那么边权为 −2∗(ay−ax)-2*(a_y-a_x)−2∗(ay​−ax​) 相等边权为 000 思路： 设终点的高度为 k<a1k &
拓扑 排序
cosx_的博客
04-13 685
拓扑排序的适用范围： 有向无环图（DAG） 学习博客
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值