强化阶段 Day 23 算法笔记 10.4 最短路径

最新推荐文章于 2022-07-01 11:07:29 发布
最新推荐文章于 2022-07-01 11:07:29 发布
阅读量403 收藏
点赞数
文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122539947
版权

目录

1.dijkstra邻接矩阵

2.Emergency

3.Travel Plan

4.bellman ford

5.Emergency(bellman)

6.spfa

7.Floyd

1.dijkstra邻接矩阵

int n,g[maxv][maxv];
int d[maxv];
bool vis[maxv]={false};

void dijkstra(int s){
	fill(d,d+maxv,inf);
	d[s]=0;
	for(int i=0;i<n;i++){
		int u=-1,min=inf;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<min){
				u=j;
				min=d[j];
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&g[u][v]!=inf&&d[u]+g[u][v]<d[v]){
				d[v]=d[u]+g[u][v];
			}
		}
	}
}

2.Emergency

#include<cstdio>
#include<cstring>
#include<stack>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxv=1000;
const int nf=1000000000;

int n,m,st,ed,g[maxv][maxv],weight[maxv];
int d[maxv],w[maxv],num[maxv];
bool vis[maxv]={false};

void dijkstra(int s){
	fill(d,d+maxv,nf);
	memset(num,0,sizeof(num));
	memset(w,0,sizeof(w));
	d[s]=0;
	w[s]=weight[s];
	num[s]=1;
	for(int i=0;i<n;i++){
		int u=-1,min_d=nf;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<min_d){
				min_d=d[j];
				u=j;
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&g[u][v]!=nf){
				if(d[u]+g[u][v]<d[v]){
					d[v]=d[u]+g[u][v];
					w[v]=w[u]+weight[v];
					num[v]=num[u];
				}else if(d[u]+g[u][v]==d[v]){
					if(w[u]+weight[v]>w[v]){
						w[v]=w[u]+weight[v];
					}
					num[v]+=num[u];
				}
			}
		}
	}
}

int main(){
	
	scanf("%d%d%d%d",&n,&m,&st,&ed);
	for(int i=0;i<n;i++){
		scanf("%d",&weight[i]);
	}
	int u,v;
	fill(g[0],g[0]+maxv*maxv,nf);
	for(int i=0;i<m;i++){
		scanf("%d%d",&u,&v);
		scanf("%d",&g[u][v]);
		g[v][u]=g[u][v];
	}
	dijkstra(st);
	printf("%d %d\n",num[ed],w[ed]);
	
	return 0;
}

3.Travel Plan

#include<cstdio>
#include<cstring>
#include<stack>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxv=505;
const int inf=1000000000;

int n,m,st,ed;
int g[maxv][maxv],cost[maxv][maxv];
int d[maxv],c[maxv];
bool vis[maxv]={false};

vector<int> pre[maxv];
void dijkstra(int st){
	fill(d,d+maxv,inf);
	d[st]=0;
	for(int i=0;i<n;i++){
		int u=-1,min_d=inf;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<min_d){
				min_d=d[j];
				u=j;
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&g[u][v]!=inf){
				if(d[u]+g[u][v]<d[v]){
					d[v]=d[u]+g[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}else if(d[u]+g[u][v]==d[v]){
					pre[v].push_back(u);
				}
			}
		}
	}
}

vector<int> temppath,path;
int mincost=inf;
void dfs(int ed){
	if(ed==st){
		temppath.push_back(ed);
		int tempcost=0;
		for(int i=temppath.size()-1;i>0;i--){
			int id=temppath[i],idnext=temppath[i-1];
			tempcost+=cost[id][idnext];
		}
		if(tempcost<mincost){
			mincost=tempcost;
			path=temppath;
		}
		temppath.pop_back();
		return;
	}
	temppath.push_back(ed);
	for(int i=0;i<pre[ed].size();i++){
		dfs(pre[ed][i]);
	}
	temppath.pop_back();
}

int main(){
	scanf("%d%d%d%d",&n,&m,&st,&ed);
	fill(g[0],g[0]+maxv*maxv,inf);
	
	int u,v;
	for(int i=0;i<m;i++){
		scanf("%d %d",&u,&v);
		scanf("%d%d",&g[u][v],&cost[u][v]);
		g[v][u]=g[u][v];
		cost[v][u]=cost[u][v];
	}
	dijkstra(st);
	dfs(ed);
	for(int i=path.size()-1;i>=0;i--){
		printf("%d ",path[i]);
	}
	printf("%d %d",d[ed],mincost);
	
	
	
	return 0;
	
}
#include<cstdio>
#include<cstring>
#include<stack>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxv=505;
const int inf=1000000000;

int n,m,st,ed;
int g[maxv][maxv],cost[maxv][maxv];
int d[maxv],c[maxv];
bool vis[maxv]={false};
int pre[maxv];

void dijkstra(int s){
	fill(d,d+maxv,inf);
	fill(c,c+maxv,inf);
	for(int i=0;i<n;i++) pre[i]=i;
	d[s]=0;
	c[s]=0;
	for(int i=0;i<n;i++){
		int u=-1,min_d=inf;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<min_d){
				min_d=d[j];
				u=j;
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&g[u][v]!=inf){
				if(d[u]+g[u][v]<d[v]){
					d[v]=d[u]+g[u][v];
					c[v]=c[u]+cost[u][v];
					pre[v]=u;
				}else if(d[u]+g[u][v]==d[v]){
					if(c[v]>c[u]+cost[u][v]){
						c[v]=c[u]+cost[u][v];
						pre[v]=u;
					}
				}
			}
		}
	}
}

void dfs(int v){
	if(v==st){
		printf("%d ",v);
		return;
	}
	dfs(pre[v]);
	printf("%d ",v);
}

int main(){
	
	scanf("%d%d%d%d",&n,&m,&st,&ed);
	int u,v;
	fill(g[0],g[0]+maxv*maxv,inf);
	fill(cost[0],cost[0]+maxv*maxv,inf);
	for(int i=0;i<m;i++){
		scanf("%d%d",&u,&v);
		scanf("%d%d",&g[u][v],&cost[u][v]);
		g[v][u]=g[u][v];
		cost[v][u]=cost[u][v];
	}
	dijkstra(st);
	dfs(ed);
	printf("%d %d",d[ed],c[ed]);
	return 0;
	
}

4.bellman ford

struct node{
	int v,dis;
};
const int maxv=5005;
const int inf=100000000;
vector<node> adj[maxv];

int n;
int d[maxv];

bool bellman(int s){
	fill(d,d+maxv,inf);
	d[s]=0;
	for(int i=0;i<n-1;i++){
		for(int u=0;u<n;u++){
			for(int j=0;j<adj[u].size();j++){
				int v=adj[u][j].v;
				int dis=adj[u][j].dis;
				if(d[u]+dis<d[v]){
					d[v]=d[u]+dis;
				}
			}
		}
	}
	for(int u=0;u<n;u++){
		for(int j=0;j<adj[u].size();u++){
			int v=adj[u][j].v;
			int dis=adj[u][j].dis;
			if(d[u]+dis<d[v]){
				return false;
			}
		}
	}
	return true;
}

5.Emergency(bellman)

#include<cstdio>
#include<cstring>
#include<stack>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxv=505;
const int inf=0x3fffffff;

struct node{
	int v,dis;
	node(int _v,int _dis) : v(_v),dis(_dis) {}
};
vector<node> adj[maxv];

int n,m,st,ed,weight[maxv];
int d[maxv],w[maxv],num[maxv];
set<int> pre[maxv];

void bellman(int s){
	fill(d,d+maxv,inf);
	memset(num,0,sizeof(num));
	memset(w,0,sizeof(w));
	d[s]=0;
	w[s]=weight[s];
	num[s]=1;
	for(int i=0;i<n-1;i++){
		for(int u=0;u<n;u++){
			for(int j=0;j<adj[u].size();j++){
				int v=adj[u][j].v;
				int dis=adj[u][j].dis;
				if(d[u]+dis<d[v]){
					d[v]=d[u]+dis;
					w[v]=w[u]+weight[v];
					num[v]=num[u];
					pre[v].clear();
					pre[v].insert(u);
				}else if(d[u]+dis==d[v]){
					if(w[u]+weight[v]>w[v]){
						w[v]=w[u]+weight[v];
					}
					pre[v].insert(u);
					num[v]=0;
					set<int>::iterator it;
					for(it=pre[v].begin();it!=pre[v].end();it++){
						num[v]+=num[*it];
					}
				}
			}
		}
	}
}

int main(){
	scanf("%d%d%d%d",&n,&m,&st,&ed);
	for(int i=0;i<n;i++){
		scanf("%d",&weight[i]);
	}
	int u,v,wt;
	for(int i=0;i<m;i++){
		scanf("%d%d%d",&u,&v,&wt);
		adj[u].push_back(node(v,wt));
		adj[v].push_back(node(u,wt));
	}
	bellman(st);
	printf("%d %d\n",num[ed],w[ed]);
	return 0;
}

6.spfa

bool spfa(int s){
	fill(d,d+maxv,inf);
	memset(inq,false,sizeof(inq));
	memset(num,0,sizeof(num));
	
	queue<int> q;
	q.push(s);
	inq[s]=true;
	num[s]++;
	d[s]=0;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		inq[u]=false;
		for(int j=0;j<adj[u].size();j++){
			int v=adj[u][j].v;
			int dis=adj[u][j].dis;
			if(d[u]+dis<d[v]){
				d[v]=d[u]+dis;
				if(inq[v]==false){
					q.push(v);
					inq[v]=true;
					num[v]++;
					if(num[v]>n) return false;
				}
			}
		}
	}
	return true;
}

7.Floyd

void floyd(){
	for(int k=0;k<n;k++){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(dis[i][k]!=inf&&dis[k][j]!=inf){
					if(dis[i][k]+dis[k][j]<dis[i][j]){
						dis[i][j]=dis[i][k]+dis[k][j];
					}
				}
			}
		}
	}
}

是小肖啊！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
r1笔记day23 负载均衡 3
01-20
在本案例中，我们探讨的是如何在一个Go语言的环境中实现一个支持用户自定义算法的负载均衡系统。 首先，我们要创建一个管理调度算法的模块。这可以通过定义一个名为`BalanceMgr`的结构体来实现，它包含一个`...
Codeup-问题 C: 最短路径
猪の成长日记
03-20 927
题目描述 N个城市，标号从0到N-1，M条道路，第K条道路（K从0开始）的长度为2^K，求编号为0的城市到其他城市的最短距离。 输入 第一行两个正整数N（2<=N<=100）M(M<=500),表示有N个城市，M条道路， 接下来M行两个整数，表示相连的两个城市的编号。 输出 N-1行，表示0号城市到其他城市的最短路，如果无法到达，输出-1，数值太大的以MOD 10000...
【最短路】最短路径树入门
qq_43398760的博客
06-04 1744
Description n个城市用m条双向公路连接，使得任意两个城市都能直接或间接地连通。其中城市编号为1..n，公路编号为1..m。 任意个两个城市间的货物运输会选择最短路径，把这n*(n-1)条最短路径的和记为S。现在你来寻找关键公路r，公 路r必须满足：当r堵塞之后，S的值会变大（如果r堵塞后使得城市u和v不可达，则S为无穷大）。 Input 第1行包含两个整数n,m， 接下来的m行，...
最短路径算法--最短路径问题
duganlx的博客
07-21 1092
最短路径问题 给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。 Input 输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点。n和m为0时输入结束。  (1&lt;n&lt;=1000,...
求最短路径的3种基本方法
weixin_43414130的博客
08-02 2万+
求最短路径的3种基本方法 情景简述：n个城市，m条道路，已知每条道路的长度。 1.多源最短路：Floyd-Warshall算法 2.单源最短路：Dijkstra算法 3.1解决负权边：Bellman-Ford算法 3.2Bellman-Ford的队列优化 总体思路就是：借助中间中间城市 来使得该城市相连的两个城市的路径变短。（就好比A要找C办事，但A不认识C，处理事情就相对麻烦。但A认识B， B认...
BJFU_数据结构习题_273基于Dijsktra算法的最短路径求解
雪地行进
11-23 2769
欢迎登录北京林业大学OJ系统 http://www.bjfuacm.com 273基于Dijsktra算法的最短路径求解 描述 一张地图包括n个城市，假设城市间有m条路径（有向图），每条路径的长度已知。给定地图的一个起点城市和终点城市，利用Dijsktra算法求出起点到终点之间的最短路径。 输入 多组数据，每组数据有m+3行。第一行为两个整数n和m，分别代表城市个数n和路径条数m。第二行有n个字符，代表每个城市的名字。第三行到第m+2行每行有两个字符a和b和一个整数d，代表从城市a到城市b有一条距离为d的路
Day2 HTML笔记存档.md
最新发布
11-02
Day2 HTML笔记存档.md
day10 23 笔记本USB接口案例 分析
08-31
day10_23_笔记本USB接口案例_分析
day4 java笔记.md
01-19
day4 java笔记.md
【前端学习笔记day09】2.5. html图像标签、绝对路径和相对路径
01-08
html图像标签、绝对路径和相对路径html图像标签、绝对路径和相对路径html图像标签绝对路径和相对路径 2.5. html图像标签、绝对路径和相对路径 绝对路径和相对路径 像网页上插入图片这种外部文件，需要定义文件的...
问题 D: 最短路径
qq_36684096的博客
03-08 775
问题 D: 最短路径 [命题人 : 外部导入] 时间限制 : 1.000 sec 内存限制 : 32 MB 题目描述 有n个城市m条道路（n<1000, m<10000)，每条道路有个长度，请找到从起点s到终点t的最短距离和经过的城市名。 输入 输入包含多组测试数据。 每组第一行输入四个数，分别为n，m，s，t。 接下来m行，每行三个数，分别为两个城市名和距离。 输出 每组输出占两行...
最短路径问题
qq_37955484的博客
10-14 206
这类问题比较集中 基本上是“n座城市，有m条路，路有起点、终点、长度等属性，求从X到Y”这种问题的变形。我们一般采用迪杰斯特拉算法或Floyd算法来解决问题。 迪杰斯特拉算法 这里，我们就以典型例子为例来解答,请看代码： import java.util.Scanner; public class 迪杰斯 { public static void main(String[] args){ ...
最短路径
weixin_41958296的博客
03-04 809
题目描述 N个城市，标号从0到N-1，M条道路，第K条道路（K从0开始）的长度为2^K，求编号为0的城市到其他城市的最短距离 输入描述: 第一行两个正整数N（2&amp;lt;=N&amp;lt;=100）M(M&amp;lt;=500),表示有N个城市，M条道路 接下来M行两个整数，表示相连的两个城市的编号 输出描述: N-1行，表示0号城市到其他城市的最短路，如果无法到达，输出-1，数值太大的以MOD 100000 ...
第三章课后习题24-33
qq_43699776的博客
02-15 406
3.24 int g(int m,int n); int main() { int m,n; cout<<"请输入m和n的值："; cin>>m>>n; if(n>=0) cout<<g(m,n)<<endl; else cout<<"No Solution！"; return 0; } int g(int m,int n) { if(m>0) return (g(m-1,2*n)+n); else
算法竞赛进阶指南：装满的油箱（Python）
KS的博客
07-01 324
有 N 个城市（编号0、1…N−1）和 MM 条道路，构成一张无向图。在每个城市里边都有一个加油站，不同的加油站的单位油价不一样。现在你需要回答不超过 100 个问题，在每个问题中，请计算出一架油箱容量为 C 的车子，从起点城市 S 开到终点城市 E 至少要花多少油钱？注意： 假定车子初始时油箱是空的。输入格式第一行包含两个整数 N 和 M。第二行包含 N 个整数，代表 N 个城市的单位油价，第 i 个数即为第 i 个城市的油价 pi。接下来 M 行，每行包括三个整数 u,v,d，表示城市 u 与城市 v
简单图论：遍历所有最短路径
haibaer
11-16 2万+
今天遇到了两道要求遍历所有最短路径的题，我一直做不对的原因竟是我把无向图当成了有向图，郁闷的要死。 解决遍历所有最短路径，其实思路很简单，首先通过经典算法[各种算法，Dijkstra,bellman,floyd]求出最短路径的长度，然后就只能DFS来找寻起始点、终点一样，长度为最短路径长度的路径即可，在DFS中可以使用Path[]数组来保存路径。 DFS时注意要剪枝，路径上已经走过的点不要重复
遍历所有点的最短路径python_图遍历算法之最短路径Dijkstra算法
weixin_39535349的博客
12-20 6609
一、最短路径问题(shortest path problem)最短路径问题是图论研究中一个经典算法问题，旨在寻找图中两节点或单个节点到其他节点之间的最短路径。根据问题的不同，算法的具体形式包括：确定起点的最短路径问题，即给定起始节点，求该节点到其他剩余节点的最短路径，适合使用Dijkstra算法；确定终点的最短路径问题，即给定终点，求其他节点到该终点的最短路径。在无向图中，该问题与确定起点的问题等...
最短路径算法_最短路径之A*算法
weixin_39819661的博客
12-05 1640
在求最短路径问题是，如果去除负权边的情况，可以使用Dijkstra算法来替代贝尔曼-福特算法，复杂度更优。接下来介绍的A*算法，也是一种相对更优的算法。看下图：示意图使用Dijkstra算法来计算AB的最短路径，基本上要把所有的点、边都遍历，才能得到最短路径——绿线。但是站在人类的角度来看，蓝线是不需要考虑的，因为有个成语叫“南辕北辙”，我们非常清楚地知道，按照蓝线走，哪怕走一步，都离目标B远了。...
最短路径问题（更新）
热门推荐
sky的博客
05-12 3万+
转载自：最短路径问题 问题介绍 简单地说，就是给定一组点，给定每个点间的距离，求出点之间的最短路径。 路径问题大概有以下几种： 确定起点的最短路径问题：已知起始点，求起点到其他任意点最短路径的问题。即单源最短路径问题。 确定终点的最短路径问题：与确定起点的问题相反，该问题是已知终点，求最短路径的问题。在无向图（即点之间的路径没有方向的区别）中该问题与确定起点的问题完全等同，在有向图（路径间有确定的方向）中该问题等同于把所有路径方向反转的确定起点的问题。 确定起点终点的最短路径
华中科大算法导论实验：近点对、大数运算与最短路径问题详解
2. 实验二至八：涉及大数运算、Root表问题、最短路径问题、以及PoJ（Problem of the Day）系列的多个编程挑战。每个实验都包含了实验内容与要求、算法设计（例如，可能用到贪心算法、动态规划或图算法等）、实验结果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值