最短路/次短路/K短路

最新推荐文章于 2022-01-10 19:56:23 发布
最新推荐文章于 2022-01-10 19:56:23 发布
阅读量133 收藏 1
点赞数
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45759072/article/details/119245799
版权

最短路

题目：poj1511
题意：n个点m条边的有向带权图，求1到所有点的最短路+除1的所有点的最短路只和。

**一开始的思路：**没注意n,m的范围（1e5），先来一波1到n，再来一波2-n到1，愉快的t了。

正解： 需要特别处理的是2-n到1的最短路，一开始确实没想到，这里感谢涛涛的讲解！
处理的话，就是把边反向建一下，再跑一遍1到所有点的的最短路，就可以了。我是**

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <math.h>
#include <map>
#include <bitset>
#include <stdlib.h>
using namespace std;
typedef long long ll;
#define pb push_back
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
typedef pair<int , int> p;
#define mp make_pair

int t, n, m;

const int maxn = 1e6 + 100;
ll dis[maxn], vis[maxn], w[maxn];
int u[maxn], v[maxn];

struct node{
	int x;
	int w;
};

struct Node{
	int x;
	ll w;
	friend bool operator < (Node a, Node b){
		return a.w > b.w;
	}
};

priority_queue<Node> q;
vector<node>vec[maxn];

void dij(int st){
	while(!q.empty()) q.pop();
	dis[st] = 0;
	q.push((Node){st, 0});
	while(!q.empty()){
		Node c = q.top();
		q.pop();
		if(vis[c.x]) continue;
		vis[c.x] = 1;
		int len = vec[c.x].size();
		for(int i = 0; i < len; i++){
			int xx = vec[c.x][i].x;
			if(!vis[xx] && dis[c.x] + vec[c.x][i].w < dis[xx]){
				dis[xx] = dis[c.x] + vec[c.x][i].w;
				q.push((Node){xx, dis[xx]});
			}
		}
	}
}

int main(){
	scanf("%d", &t);
	while(t--){
		scanf("%d %d", &n, &m);
		for(int i = 1; i <= n; i++){
			vec[i].clear();
			dis[i] = INF;
			vis[i] = 0;
		}
		for(int i = 1; i <= m; i++){
			scanf("%d %d %lld", &u[i], &v[i], &w[i]);
			vec[u[i]].pb((node){v[i], w[i]});
		}
		dij(1);
		ll ans = 0;
		for(int i = 1; i <= n; i++){
			ans += dis[i];
		}

		for(int i = 1; i <= n; i++) vec[i].clear();
		for(int i = 1; i <= m; i++) vec[v[i]].pb((node){u[i], w[i]});

		for(int j = 1; j <= n; j++) dis[j] = INF, vis[j] = 0;
		dij(1);
		for(int i = 2; i <= n; i++) ans += dis[i];

		printf("%lld\n", ans);
	}
		
	return 0;
}

题目：hdu2066
题意：大意是有一个无向带权图共有t条边，接着给你s个起点，d个终点，问从任意起点至任意终点的最短路。
很妙的思路：（我觉得很妙，不认同我就…_：
用的优先队列优化跑的最短路，直接把s个起点塞进队列，然后直接跑最短路，最后对d的终点取min就可以了

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <math.h>
#include <map>
#include <bitset>
#include <stdlib.h>
using namespace std;
typedef long long ll;
#define pb push_back
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;

int t, s, d;
const int maxn = 1e3 + 5;
ll a[maxn][maxn], dis[maxn], w;
int u, v, st[maxn], ed[maxn], vis[maxn], used[maxn][maxn];

vector<int>vec[maxn];

struct node{
	ll x;
	ll w;
	friend bool operator < (node a, node b){
		return a.w > b.w;
	}
};

priority_queue<node> q;

void dij(){
	for(int i = 1; i <= s; i++){
		dis[st[i]] = 0;
	}
	while(!q.empty()){
		node c = q.top();
		q.pop();
		if(vis[c.x]) continue;
		vis[c.x] = 1;
		int len = vec[c.x].size();
		for(int i = 0; i < len; i++){
			int xx = vec[c.x][i];
			if(!vis[xx] && dis[c.x] + a[c.x][xx] < dis[xx]){
				dis[xx] = dis[c.x] + a[c.x][xx];
				q.push((node){xx, dis[xx]});
			}
		}
	}
}

void init(){
	for(int i = 0; i <= 1000; i++){
		vec[i].clear();
		dis[i] = INF;
		for(int j = 0; j <= 1000; j++){
			if(i == j)
				a[i][j] = 0;
			else
				a[i][j] = INF;
			used[i][j] = 0;
		}
		vis[i] = 0;
	}
}

int main(){
	while(~scanf("%d %d %d", &t, &s, &d)){
		init();
		for(int i = 1; i <= t; i++){
			scanf("%d %d %lld", &u, &v, &w);
			if(!used[u][v]){
				vec[u].pb(v);
				vec[v].pb(u);
			}
			used[u][v] = used[v][u] = 1;
			a[u][v] = min(a[u][v], w);
			a[v][u] = min(a[v][u], w);
		}

		for(int i = 1; i <= s; i++){
			scanf("%d", &st[i]);
			q.push((node){st[i], 0});
		}
		dij();
		for(int i = 1; i <= d; i++)	scanf("%d", &ed[i]);
		ll ans = INF;
		for(int i = 1; i <= d; i++){
			ans = min(ans, dis[ed[i]]);
		}
		cout << ans << endl;	
	}
	return 0;
}

次短路&K短路

一篇非常非常棒的博客！！！

次短路题目链接
求次短路
方法一：

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <math.h>
#include <map>
#include <bitset>
#include <stdlib.h>
using namespace std;
typedef long long ll;
#define pb push_back
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;

int n, m, u, v, t;
ll w, dis1[maxn], dis2[maxn];

struct edge{
	int x;
	ll w;
};

struct node{
	int x;
	ll w;
	friend bool operator < (node a, node b){
		return a.w > b.w;
	}
};

vector <edge> vec[maxn*2];

void dij(){
	priority_queue <node> q;
	dis1[1] = 0;
	q.push((node){1, 0});
	while(!q.empty()){
		node c = q.top();
		q.pop();
		if(dis2[c.x] < c.w) continue;
		int len = vec[c.x].size();
		for(int i = 0; i < len; i++){
			int xx = vec[c.x][i].x;
			ll ww = c.w + vec[c.x][i].w;
			if(dis1[xx] > ww){
				q.push((node){xx, ww});
				swap(dis1[xx], ww);
			}
			if(dis2[xx] > ww && ww > dis1[xx]){
				dis2[xx] = ww;
				q.push((node){xx, dis2[xx]});
			}
		}
	}
}


void init(){
	for(int i = 0; i <= n; i++){
		dis1[i] = dis2[i] = INF;
		vec[i].clear();
	}
}

int main(){
	scanf("%d", &t);
	while(t--){
		scanf("%d %d", &n, &m);
		init();
		for(int i = 1; i <= m; i++){
			scanf("%d %d %lld", &u, &v, &w);
			vec[u].pb((edge){v, w});
			vec[v].pb((edge){u, w});
		}
		dij();
		printf("%lld\n", dis2[n]);
	}
	return 0;
}

方法二：
注意： 这个方法要特判一下只有一条边的情况，它会来回跑一遍，然后再跑一遍，故答案乘三

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <math.h>
#include <map>
#include <bitset>
#include <stdlib.h>
using namespace std;
typedef long long ll;
#define pb push_back
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;

const int maxn = 1e5 + 5;
int n, m, u[maxn], v[maxn], t;
ll w[maxn], dis1[maxn], dis2[maxn];
int vis[maxn];

struct edge{
	int x;
	ll w;
};

struct node{
	int x;
	ll w;
	friend bool operator < (node a, node b){
		return a.w > b.w;
	}
};

vector <edge> vec[maxn*2];

void dij(){
	priority_queue <node> q;
	priority_queue <node> q1;
	dis1[1] = dis2[n] = 0;
	q.push((node){1, 0});
	q1.push((node){n, 0});

	while(!q.empty()){
		node c = q.top();
		q.pop();
		if(vis[c.x]) continue;
		vis[c.x] = 1;
		int len = vec[c.x].size();
		for(int i = 0; i < len; i++){
			int xx = vec[c.x][i].x;
			ll ww = vec[c.x][i].w;
			if(!vis[xx] && dis1[xx] > dis1[c.x] + ww){
				dis1[xx] = dis1[c.x] + ww;
				q.push((node){xx, dis1[xx]});
			}
		}
	}
	for(int i = 1; i <= n; i++) vis[i] = 0;
	while(!q1.empty()){
		node c = q1.top();
		q1.pop();
		if(vis[c.x]) continue;
		vis[c.x] = 1;
		int len = vec[c.x].size();
		for(int i = 0; i < len; i++){
			int xx = vec[c.x][i].x;
			ll ww = vec[c.x][i].w;
			if(!vis[xx] && dis2[xx] > dis2[c.x] + ww){
				dis2[xx] = dis2[c.x] + ww;
				q1.push((node){xx, dis2[xx]});
			}
		}
	}
}

void getAns(){
	if(m == 1){
		printf("%lld\n", w[1] * 3);
		return ;
	}
	ll ans = INF;
	ll op = dis1[n];
	for(int i = 1; i <= m; i++){
		int x = u[i], y = v[i]; 
		ll tmp = dis1[x] + dis2[y] + w[i];
		if(tmp == op) continue;
		ans = min(ans, tmp);
	}
	printf("%lld\n", ans);
}

void init(){
	for(int i = 0; i <= n; i++){
		dis1[i] = dis2[i] = INF;
		vec[i].clear();
		vis[i]= 0;
	}
}

int main(){
	scanf("%d", &t);
	while(t--){
		scanf("%d %d", &n, &m);
		init();
		for(int i = 1; i <= m; i++){
			scanf("%d %d %lld", &u[i], &v[i], &w[i]);
			vec[u[i]].pb((edge){v[i], w[i]});
			vec[v[i]].pb((edge){u[i], w[i]});
		}
		dij();
		getAns();
	}
	return 0;
}
HYYyyying
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【图论算法】 最短路，次短路，k短路总结
一个蒟蒻的博客
10-11 1362
在图论里，最短路，次短路，k短路的问题很常见。 这里总结一下。 存图技巧 数据小，稠密图的一般用邻接矩阵 稀疏图，数据大一般用邻接表（vector,链式前向星都可) 邻接矩阵 const int maxn = 1e5+5; int Graph[maxn][maxn]; // 正权图可以初始化成-1来判断是否连通，负权图可以再考虑开个数组或者用一个很大的值。 链式前向星 const int max...
次短路，第k最短路，有限制的最短路问题总结
cjl3011的专栏
09-10 2577
在这求第k短路用的是，A*+dij所谓的A*是一种启发式搜索，他给搜索选定一定的方向，避免了无谓的搜索，如何来确定搜索的顺序？也就是用一个值来表示这个值为f[x]，每次搜索取f[x]最小的拓展，那么这个f[x]=h[x]+g[x]其中这个h[x]就是当前搜索时的代价，如求K段路这个就是前一个点的h[x']+边的长度，而g[x]是一个估价函数，估价函数要小于是对当前点到目标的代价的估计，这个估计必须
K短路问题（A*启发式广搜）
Khasehemwy的博客
07-25 489
k短路问题就是最短路问题的延申，要找出第k短的路径。用广搜进行路径查找，第一次找到的就是最短路，第二次找到的是第2短路…以此类推。所以我们只需要一直广搜直到找到k次终点，这时即为第k短路。 但直接暴力广搜会占用很多空间和时间，如下图： (图片来源：https://www.cnblogs.com/shenben/p/5580026.html) 所以需要进行优化。可采用A*启发式搜索优化。 先看看A*优化的广搜： 启发式搜索： 又叫有信息的搜索，有人工智能的感觉，就是不像暴力搜索一样每次向外扩展一层，而
最短路/次短路
qq_55788328的博客
01-10 671
单源最短路: dijkstra和spfa。dijkstra可以用于求解没有负边的最短路时间复杂度为nlogn（n是边数） spfa可以求解没有负边的最短路时间复杂度为Ke(K是常数，e是边数) 多源最短路:floyd 可以求解没有负圈的最短路 Dijkstra #include<bits/stdc++.h> #define int long long using namespace std; const int maxn=1e3+5; const int inf=1e9+7; in...
最短路和次短路.zip
05-14
采用matlab语言编写高效程序，实现快速又高效的最短路和次短路算法
次短路 && k短路
sxhlrLX的博客
12-21 229
文章目录次短路 再了解次短路与kkk短路之前，我们先了解一下最短路。 次短路 次短路就是简化版的kkk短路，我们先把这个了解了。 题目传送门 这是一道典型的次短路问题。 我们都知道次短路是由最短路改变而来的。 但我们怎么改？什么时候改？ 那当然是修改的时候啦。 我们再更新最短路时就把次短路更新掉。 我们定义dist_fdist\_fdist_f为最短路，dist_sdist\_sdist_s为次短路。则我们更新有三种情况： 1.当dist_f[v]>dist_f[u]+wdist\_f[v]>d
最短路和次短路_matlab
04-17
资源名：最短路和次短路_matlab 资源类型：matlab项目全套源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的，如果您下载后不能运行可联系我进行指导或者更换。 适合人群：新手及有一定经验的开发...
动态最短路_动态最短路算法程序_
10-03
动态最短路算法是图论中的一个重要概念，用于在带权重的有向或无向图中寻找从一个起点到其他所有节点的最短路径。在实际应用中，它广泛应用于网络设计、物流优化、交通路线规划等领域。在这个场景中，我们讨论的是...
matlab最短路.txt
08-11
matlab最短路.txt
用matlab实现寻找最短路.docx
最新发布
11-15
"用matlab实现寻找最短路" 本文档介绍了如何使用matlab来实现寻找最短路问题的解决方案。最短路问题是图论理论中的经典问题，它在many real-world applications中都有重要的应用价值。 图论是应用数学的一个分支，...
[jzoj1163]第K短路
FarmerJohn
07-20 348
Solution 模板题 可以练练A*+Dij 注意它重新定义K短路为长度不同第K短 另外出数据的人喝了假酒 数据假得很有节奏 比如: 654 10000 100 359 388 7152 359 388 395 553 8580 553 395 357 555 4237 357 555 408 423 3844 ...
k短路
huyuncong的专栏
10-29 894
本来很早以前就用线段树写了一遍，但是居然mle了。。。 先用dij求各点到汇点的最短路f[i]，再从源点bfs A*搜，g[j]:=g[i]+c[i,j];g表示到源点距离，每次扩展都选g[i]+f[i]最小的点，向其他点扩展一种状态而不是点，所以优先队列中的点可能超过n。 优先队列可以用堆实现，用线段树会爆空间，但是我用惯了zkw线段树，不会写二叉堆，于是用可并堆实现了。 const ma
【模板】K短路的稳定复杂度求法
zxyoi_dreamer的博客（不定期诈尸）
01-24 849
描述 给出一个有向图，你需要求出SSS到TTT的所有路径中权值第kkk小的路径的权值。 这里的第kkk小是指，将所有本质不同的路径的权值排序后（不去重），从小到大排名为kkk。 数据保证KKK短路一定存在。 数据卡A∗A*A∗以及乱搞+A∗A*A∗。 输入 第一行两个整数n,mn,mn,m表示点数和边数。 然后mmm行三个整数ui,vi,wiu_i,v_i,w_iui​,vi​,wi​表示m条边。...
最短路和次短路方案数poj3463
lengxuenong的博客
12-29 491
最短路和次短路的方案数。 最短路方案数：                    > 更新最短路，重新计数                    = 出现新的方案，累计 最短路和次短路                   最短路被最短路更新，同时次短路更新                   最短路出现新方案                    次短路更新，可能被最短路更新，也可能被
acm专题学习之最短路（四）次短路+LightOJ - 1099
qq_40306845的博客
04-07 266
次短路 定义：找出第二短的路径长，次于最短路。 思路：求两次最短路，一个是到起点的最短路，一个是到终点的最短路。然后遍历每一条边，每一条边的两个点分别到终点和起点的最短路的和+边的长度，如果这个和大于最短路，就让ans取这些路中的最小值就好了。 LightOJ - 1099 题意：给你n个点，m条边，让你求出次短路（次短路的长度要小于最短路，相同的不算） 思路：次短路的思路。 代码：...
【POJ 2449】Remmarguts' Date(A*+dij求k短路)
Loi_Chairmanの博客
09-19 430
qwq 原题面，英文emmmm…… 想看中文版可以滑到下面去√ k短路A*的经典题目
Sightseeing（最短路与次短路之和）
BadGuy的博客
11-29 687
Sightseeing Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d & %I64uDescription Tour operator Your Personal Holiday organises guided bus trips across the Benelux. Every day the bus m
Dijkstra求最短路与次短路
qq_25971709的专栏
04-28 2534
花了一个晚上加上午两节课的时间来思考这个问题，一开始进了个误区，后来发现不对，找到了正确思路，现在来做个总结 最短路： 假设有如下 无向图： 每条边有权，要求从A到G的最短路，设数组d[i]用来记录每个点到A的最短路，D[][]用来记录权值d[0]=0。先来说一下我一开始的误区，在看了一些介绍这个算法的文章后我大概知道了是要一步一步来更新每个点的最小值。于是我是这样想的从A到B遍历，
最短路和次短路条数
Code-Dreamer的博客
01-28 1451
问题描述：                   给你一张无向图或有向图，要你求任意两点的最短路条数或次短路条数 算法描述：               1，最短路：                              对于最短路条数，我们很容易想到的是加法原则，我们可以在用dij求最短路的时候，                        当dis[j]=dis[to]+
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值