PAT——最短路径

最新推荐文章于 2021-09-05 10:12:41 发布
最新推荐文章于 2021-09-05 10:12:41 发布
阅读量216 收藏
点赞数
分类专栏： PAT甲级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39825375/article/details/100070974
版权

 1018 Public Bike Management (30 分)  （Dijkstra+dfs）

There is a public bike service in Hangzhou City which provides great convenience to the tourists from all over the world. One may rent a bike at any station and return it to any other stations in the city.

The Public Bike Management Center (PBMC) keeps monitoring the real-time capacity of all the stations. A station is said to be in perfect condition if it is exactly half-full. If a station is full or empty, PBMC will collect or send bikes to adjust the condition of that station to perfect. And more, all the stations on the way will be adjusted as well.

When a problem station is reported, PBMC will always choose the shortest path to reach that station. If there are more than one shortest path, the one that requires the least number of bikes sent from PBMC will be chosen.

The above figure illustrates an example. The stations are represented by vertices and the roads correspond to the edges. The number on an edge is the time taken to reach one end station from another. The number written inside a vertex SSS is the current number of bikes stored at SSS. Given that the maximum capacity of each station is 10. To solve the problem at S3S_3S​3​​, we have 2 different shortest paths:

  1. PBMC -> S1S_1S​1​​ -> S3S_3S​3​​. In this case, 4 bikes must be sent from PBMC, because we can collect 1 bike from S1S_1S​1​​ and then take 5 bikes to S3S_3S​3​​, so that both stations will be in perfect conditions.

  2. PBMC -> S2S_2S​2​​ -> S3S_3S​3​​. This path requires the same time as path 1, but only 3 bikes sent from PBMC and hence is the one that will be chosen.

Input Specification:

Each input file contains one test case. For each case, the first line contains 4 numbers: CmaxC_{max}C​max​​ (≤100\le 100≤100), always an even number, is the maximum capacity of each station; NNN (≤500\le 500≤500), the total number of stations; SpS_pS​p​​, the index of the problem station (the stations are numbered from 1 to NNN, and PBMC is represented by the vertex 0); and MMM, the number of roads. The second line contains NNN non-negative numbers CiC_iC​i​​ (i=1,⋯,Ni=1,\cdots ,Ni=1,⋯,N) where each CiC_iC​i​​ is the current number of bikes at SiS_iS​i​​ respectively. Then MMM lines follow, each contains 3 numbers: SiS_iS​i​​, SjS_jS​j​​, and TijT_{ij}T​ij​​ which describe the time TijT_{ij}T​ij​​ taken to move betwen stations SiS_iS​i​​ and SjS_jS​j​​. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print your results in one line. First output the number of bikes that PBMC must send. Then after one space, output the path in the format: 0−>S1−>⋯−>Sp0->S_1->\cdots ->S_p0−>S​1​​−>⋯−>S​p​​. Finally after another space, output the number of bikes that we must take back to PBMC after the condition of SpS_pS​p​​ is adjusted to perfect.

Note that if such a path is not unique, output the one that requires minimum number of bikes that we must take back to PBMC. The judge's data guarantee that such a path is unique.

Sample Input:

10 3 3 5
6 7 0
0 1 1
0 2 1
0 3 3
1 3 1
2 3 1

Sample Output:

3 0->2->3 0

题意：

  • cmax——自行车站最大容量
  • n个自行车站点（1~n），中心顶点为0
  • m条道路，在该路上花费时间t
  • sp——问题车站的顶点序号
  • 自行车站三种状态：prefect (num=cmax/2)   need需总部往外派车 (num<cmax/2)   back需总部往回拉车 (num>cmax/2)
  • 求一出行路线，使sp变为perfect状态，路径最短（即所需时间最少），所需need最少（need相同时back最少）

思路：

最短路径：Dijkstra

  • dis[ ]
  • mp[ ][ ]
  • vis[ ]
  • vector<int>pre[505]（记录节点的前一个节点）以助dfs

need最少：dfs

  • w[ ] 记录个顶点与perfect状态之差
  • vector<int> tmpPath（当前尝试的路径）
  • vector<int> path  (最终答案，从sp到0逆序)
  1. 递归出口，回溯到0，而后开始计算need和back，遍历tmpPath中每个节点的w[i], 三种情况（w[i]>0,w[i]<0&&back够，w[i]<0&&back不够need来凑），更新minNeed、minBack、path或minBack、path。之后经行下一个尝试，删掉当前元素tmpPath.pop_back()并return
  2. 函数体内部，遍历pre[v].size() 依次深搜
  3. tmpPath.pop_back()
  • fill(mp[0],mp[0]+505*505,inf);
  • fill(dis,dis+505,inf);
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
int w[505],dis[505],mp[505][505],vis[505];
vector<int> pre[505],tmpPath,path;
const int inf=999999999;
int minBack=inf,minNeed=inf;
int cmax,n,sp,m;
void dfs(int v) {
	tmpPath.push_back(v);
	if(v==0) {
		int need=0,back=0;
		for(int i=tmpPath.size()-1;i>=0;i--) {             //遍历tmpPath中个点的w[i]
			int id=tmpPath[i];
			if(w[id]>0) back+=w[id];
			else {
				if(back>-w[id]) back+=w[id];
				else need+=-w[id]-back,back=0;
			}
		}
		if(minNeed>need) {                                //题目需求，先路径最短，后need最少，后back最少
			minNeed=need;
			minBack=back;
			path=tmpPath;
		}
		else if(minNeed==need&&minBack>back){
				minBack=back;
				path=tmpPath;
		}
		tmpPath.pop_back();                              //进行下一尝试，退出当前元素
		return;
	}
	for(int i=0;i<pre[v].size();i++)
		dfs(pre[v][i]);
	tmpPath.pop_back();                                      //再回退一步，走一下最后两步试试
} 
int main() {
	fill(mp[0],mp[0]+505*505,inf);
	fill(dis,dis+505,inf);
	cin>>cmax>>n>>sp>>m;
	for(int i=1; i<=n; i++) {
		cin>>w[i];
		w[i]-=cmax/2;
	}
	int a,b,l;
	for(int i=0; i<m; i++) {
		cin>>a>>b>>l;
		mp[a][b]=mp[b][a]=l;
	}
	dis[0]=0;
	for(int i=0; i<=n; i++) {
		int minn=inf,u=-1;
		for(int j=0; j<=n; j++)
			if(vis[j]==0&&minn>dis[j]) minn=dis[j],u=j;
		if(u==-1) break;
		vis[u]=1;
		for(int j=0; j<=n; j++) {
			if(vis[j]==0&&mp[u][j]!=inf) {
				if(dis[j]>dis[u]+mp[u][j]) {
					dis[j]=dis[u]+mp[u][j];
					pre[j].clear();            //之前所有须全部清除
					pre[j].push_back(u);
				} else if(dis[j]==dis[u]+mp[u][j])
					pre[j].push_back(u);
			}
		}
	}
	dfs(sp);
	printf("%d 0",minNeed);
	for(int i=path.size()-2;i>=0;i--) printf("->%d",path[i]);
	printf(" %d",minBack);
	return 0;
}

1030 Travel Plan (30 分) （Dijkstra+dfs）

  • n个点，m条路，起点s，终点d
  • m个输入：a，b，len，cost
  • 打印最短路径，路径相同时打印最少花费路径
  1. Dijkstra：求最短路径，并计入pre
  2. dfs：深搜pre，到达目标计算sumcos更新path
  3. 注意：一次push_back()，两次pop_back();
#include<iostream>
#include<vector>
using namespace std;
const int inf=99999999;
int n,m,s,d;
int minc=inf;
int dis[505],mpd[505][505],mpc[505][505],vis[505];
vector<int> pre[505],tmpPath,path;
void dfs(int v){
	tmpPath.push_back(v);
	if(v==s){
		int sumc=0,a,b;
		for(int i=0;i<tmpPath.size()-1;i++){
			a=tmpPath[i];
			b=tmpPath[i+1];
			sumc+=mpc[a][b];
		}
		if(sumc<minc){
			minc=sumc;
			path=tmpPath;
		}
		tmpPath.pop_back();
		return;
	}
	for(int i=0;i<pre[v].size();i++)
		dfs(pre[v][i]);
	tmpPath.pop_back();
}
int main() {
	fill(mpd[0],mpd[0]+505*505,inf);
	fill(mpc[0],mpc[0]+505*505,inf);
	fill(dis,dis+505,inf);
	cin>>n>>m>>s>>d;
	int a,b,l,c;
	for(int i=0;i<m;i++){
		cin>>a>>b>>l>>c;
		mpd[a][b]=mpd[b][a]=l;
		mpc[a][b]=mpc[b][a]=c;	
	}
	dis[s]=0;
	for(int i=0;i<n;i++){
		int minn=inf,u=-1;
		for(int j=0;j<n;j++)
			if(vis[j]==0&&dis[j]<minn) minn=dis[j],u=j;
		if(u==-1)break;
		vis[u]=1;
		for(int j=0;j<n;j++){
			if(vis[j]==0&&mpd[u][j]!=inf){
				if(dis[j]>dis[u]+mpd[u][j]){
					dis[j]=dis[u]+mpd[u][j];
					pre[j].clear();
					pre[j].push_back(u);
				}else if(dis[j]==dis[u]+mpd[u][j])
					pre[j].push_back(u);
			}
		}
	}
	dfs(d);
	cout<<path[path.size()-1];
	for(int i=path.size()-2;i>=0;i--) cout<<' '<<path[i];
	printf(" %d %d",dis[d],minc);
	return 0;
}

1087 All Roads Lead to Rome (30 分)

题意：

  • n个点（每个点都是三个大写字母组成的字符），k条路，起点start
  • 除起点外每个点都有happiness值
  • 已知k条路每条路上花费的cost值
  • 求花钱最少的路径，花钱同找happiness值最大的路径，happiness值同找avgh最大的路径
  • 输出最短路径数目，最小花费，maxh，avgh

点的名称处理：

  • 输入——字符串变数字序号。将点名字编号，起点0，其余点在读入hap值时赋值为1到n-1
  • 用两个map保存字符串和序号相互的对应关系，处理图时用序号
  • 输出——数字序号变字符串。将path中存放的序号所对应的字符串输出

Dijkstra：找cost最少的路径，pre保存每点的前一个节点，易助dfs

dfs：回溯到头，cnt++，判断当前路径sumh、nowavg与maxh、avgh

#include<iostream>
#include<vector>
#include<map>
#include<string>
using namespace std;
const int inf=99999999;
int n,k,sid=0,eid,cnt=0;
int maxh=-inf,avgh=-inf;
int dis[205],hap[205]={0},cost[205][205],vis[205];
vector<int> pre[205],tmpPath,path;
map<string,int> num;
map<int,string> name;
//void getId(string s) {
//	int id=0;
//	for(int i=0; i<s.size(); i++)
//		id=id*26+s[i]-'A';
//	return id;
//}
void dfs(int v) {
	tmpPath.push_back(v);
	if(v==0) {
		cnt++;
		int sumh=0;
		for(int i=0;i<tmpPath.size();i++) //遍历tmpPath 
			sumh+=hap[tmpPath[i]];
		if(sumh>maxh) {
			maxh=sumh;
			avgh=sumh/(tmpPath.size()-1); //分母为个数减一 
			path=tmpPath;
		} else if(sumh==maxh) {
			int nowavg=sumh/(tmpPath.size()-1); //分母为个数减一
			if(avgh<nowavg) {
				avgh=nowavg;
				path=tmpPath;
			}
		}
		tmpPath.pop_back();
		return;
	}
	for(int i=0; i<pre[v].size(); i++)
		dfs(pre[v][i]);
	tmpPath.pop_back();
}
int main() {
	string start,s1,s2;
	int id1,id2,c;
	fill(cost[0],cost[0]+205*205,inf);
	fill(dis,dis+205,inf);
	cin>>n>>k>>start;
	num[start]=0; //起始点永远为0，因为无happy，有happy的点从1到n-1 
	name[0]=start;
	for(int i=1; i<n; i++) {
		cin>>s1;
		num[s1]=i;
		name[i]=s1;
		cin>>hap[i];
	}
	for(int i=0; i<k; i++) {
		cin>>s1>>s2>>c;
		id1=num[s1],id2=num[s2];
		cost[id1][id2]=cost[id2][id1]=c;
	}
	dis[0]=0;
	for(int i=0; i<n; i++) {
		int minn=inf,u=-1;
		for(int j=0; j<n; j++)
			if(vis[j]==0&&dis[j]<minn) minn=dis[j],u=j;
		if(u==-1)break;
		vis[u]=1;
		for(int j=0; j<n; j++) {
			if(vis[j]==0&&cost[u][j]!=inf) {
				if(dis[j]>dis[u]+cost[u][j]) {
					dis[j]=dis[u]+cost[u][j];
					pre[j].clear();
					pre[j].push_back(u);
				} else if(dis[j]==dis[u]+cost[u][j])
					pre[j].push_back(u);
			}
		}
	}
	eid=num["ROM"];
	dfs(eid);
	printf("%d %d %d %d\n",cnt,dis[eid],maxh,avgh);
	int idx=path.size()-1;
	cout<<name[path[idx]];
	for(int i=path.size()-2;i>=0;i--) cout<<"->"<<name[path[i]];
	return 0;
}

1111 Online Map (30 分)

  • n个点，m条路（有单向和双向的两种），求从起点s到终点d的最短路径过程，和最快的路径
  • 两次Dijkstra，一次选最短路（长度相同选速度最快的那个），一次选最快的路（一样快选点少的那个），并分别把节点保存在vector<int> prel [505] 和 pret [505]中
  • 两次dfs，一次挑最短路里最快的那条，一次挑最快路里经过点最少的那条

注意：

  • one-way指单行道
  • 两类变量很相似（下次最好起个区分度大的名字）不要搞混
#include<iostream>
#include<vector>
using namespace std;
const int inf=99999999;
int dis[505],fast[505],vis[505],mpt[505][505],mpl[505][505];
vector<int> prel[505],pret[505],tmp,shortp,fastp;
int mint=inf,minv=inf;
int n,m,s,d;
void dijkstraD() {  //0到size-1，依次从终点到起点，输出得从后往前
	dis[s]=0;
	for(int i=0; i<n; i++) {
		int minn=inf,u=-1;
		for(int j=0; j<n; j++)
			if(vis[j]==0&&dis[j]<minn) minn=dis[j],u=j;
		if(u==-1)break;
		vis[u]=1;
		for(int j=0; j<n; j++) {
			if(vis[j]==0&&mpl[u][j]!=inf) {
				if(dis[j]>dis[u]+mpl[u][j]) {
					dis[j]=dis[u]+mpl[u][j];
					prel[j].clear();
					prel[j].push_back(u);
				} else if(dis[j]==dis[u]+mpl[u][j])
					prel[j].push_back(u);
			}
		}
	}
}
void dijkstraT() {
	fast[s]=0;
	for(int i=0; i<n; i++) {
		int minn=inf,u=-1;
		for(int j=0; j<n; j++)
			if(vis[j]==0&&fast[j]<minn) minn=fast[j],u=j;
		if(u==-1)break;
		vis[u]=1;
		for(int j=0; j<n; j++) {
			if(vis[j]==0&&mpt[u][j]!=inf) {
				if(fast[j]>fast[u]+mpt[u][j]) {
					fast[j]=fast[u]+mpt[u][j];
					pret[j].clear();
					pret[j].push_back(u);
				} else if(fast[j]==fast[u]+mpt[u][j])
					pret[j].push_back(u);
			}
		}
	}
}
void dfsL(int v) {
	tmp.push_back(v);
	if(v==s) {
		int sumt=0,a,b;
		for(int i=0; i<tmp.size()-1; i++) {
			a=tmp[i];
			b=tmp[i+1];
			sumt+=mpt[b][a];
		}
		if(sumt<mint) {
			mint=sumt;
			shortp=tmp;
		}
		tmp.pop_back();
		return;
	}
	for(int i=0; i<prel[v].size(); i++)
		dfsL(prel[v][i]);
	tmp.pop_back();
}
void dfsT(int v) {
	tmp.push_back(v);
	if(v==s) {
		int sumv=tmp.size();
		if(sumv<minv) {
			minv=sumv;//
			fastp=tmp;
		}
		tmp.pop_back();
		return;
	}
	for(int i=0; i<pret[v].size(); i++)
		dfsT(pret[v][i]);
	tmp.pop_back();
}
int main() {
	fill(mpl[0],mpl[0]+505*505,inf);
	fill(mpt[0],mpt[0]+505*505,inf);
	fill(dis,dis+505,inf);
	fill(fast,fast+505,inf);
	cin>>n>>m;
	int a,b,dir,l,t;
	for(int i=0; i<m; i++) {
		cin>>a>>b>>dir>>l>>t;
		mpl[a][b]=l,mpt[a][b]=t;
		if(dir==0) mpl[b][a]=l,mpt[b][a]=t; //one-way 单向的 
	}
	cin>>s>>d;
	dijkstraD();
	dfsL(d);
	fill(vis,vis+505,0);    //共用一个vis，第二次得清空
	tmp.clear();
	dijkstraT();
	dfsT(d);
	if(shortp==fastp) {
		printf("Distance = %d; Time = %d: %d",dis[d],fast[d],s);
		for(int i=shortp.size()-2; i>=0; i--) printf(" -> %d",shortp[i]);
	} else {
		printf("Distance = %d: %d",dis[d],s);
		for(int i=shortp.size()-2; i>=0; i--) printf(" -> %d",shortp[i]);
		printf("\nTime = %d: %d",fast[d],s);
		for(int i=fastp.size()-2; i>=0; i--) printf(" -> %d",fastp[i]);
	}
	return 0;
}

@Star
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PAT——一种高性能软件验证工具
06-03
通信顺序进程（communicating sequential proces）验证软件，打开csp格式文件的软件，对开发的软件进行验证的高性能工具。
二叉树输出从根结点到值为x的结点的路径
凉城浅离的博客
11-06 4015
//假设二叉树采用二叉链存储结构。设计一个递归算法输出从根结点到值为x的结点的路径。假设二叉树中所有结点的值不同 //解法一:采用求x结点的所有祖先的方法，因为x结点加上它的所有祖先恰好构成从根结点到x结点的路径(逆向).用vector向量path存放x结点及其祖先(即从根结点到x结点的逆路径，反向输出构成正向路径)。 //f(b,x,path)(大问题)的求解过程:若b为空时，返回false;若b所指的结点为x结点，将x结点值加入到path，返回true,若b所指结点的孩子为x结点或其祖先，将b所指结点加
C++ push方法与push_back方法 浅析
热门推荐
稚枭天卓
07-12 9万+
push与push_back是STL中常见的方法，都是向数据结构中添加元素。初识STL，对于添加元素的方法以产生混淆，这里暂对两种方法作出比较分析。此外，本文还将简述push对应的stack与queue系列，常见方法的介绍，以及与push_back相对应的vector系列常见方法介绍。详见下文。
【PAT甲级复习】 专题复习一：最短路径
Harryline的博客
09-05 222
文章目录1 无负权边的单源最短路径——Dijkstra1.1 邻接矩阵版：适用于V不超过1000的情况，复杂度O(2V22V^22V2)。1.2 邻接表版：复杂度O(V2+EV^2 + EV2+E)1.3 优先队列优化的Dijkstra1.4 记录最短路径1.5 多个标尺如何处理1.5.1 新增边权1.5.2 新增点权1.5.3 求最短路径条数1.6 多个标尺且比较复杂：Dijkstra + DFS1.6.1 Dijkstra默写模板1.6.2 DFS遍历所有最短路径模板2 有负权边的单源最短路径——Bel
PAT 备考——图论算法（二）最短路径
狄利克雷的博客
11-28 799
最短路径算法是PAT甲级考试常考算法，具体说来，最短路径包括Dijkstra算法、Floyd算法，其余的Bellman-Ford和SPFA基本不会考（参《算法笔记》胡凡，曾磊著） 目录 一、最短路径基本概念与问题分类 1.基本概念 2.问题分类 二、Dijkstra算法 1.伪代码 2.示意图 3.参考代码 4.升级 5.Dijkstra+DFS   一、最短路径基本概...
pat-1087【最短路径】
知识源于积累
10-20 1949
最短路径
PAT乙级题解.pdf
最新发布
04-19
PAT题解分享，超级详细
个性化旅游推荐系统——PAT验证
01-08
PAT验证说明文档.docx （含模型及代码） 个性化旅游推荐系统——管理员.csp 个性化旅游推荐系统——游客.csp 个性化旅游推荐系统.pptx
PAT甲级所有题解代码
02-03
这里包含了179道PAT甲级的代码AC题解，供有需要通过PAT考试的同学下载学习使用。
PAT题解，PAT题解
02-16
PAT题解
最短路径 pat 1003
BuGengFeng的博客
09-03 161
#include <iostream> //1003 using namespace std; const int N = 510; const int inf = 1e9; int n,m,st,ed; int vis[N]={0}; int G[N][N] = {0}; int w[N],weight[N]; int d[N]; int num[N]; void dij(int ...
【ACM】- PAT. A1072 Gas Station 【图 - 最短路径】
三个石头
08-26 403
题目链接 题目分析 给出M个加油站待选点和N个房屋，要求加油站距离最近的房子越远越好；（即最小距离中最大的那个） 当有相同解时，选择平均距离更小的那一个，若还有多解，选择编号更小的那一个 民房编号 1~N（1000）; 气站编号G1~GM（10）； 解题思路 对于所有候选站点，依次执行如下步骤： Dijkstra()算法查找最短路径，只需记录到每个结点的最短距离即可，不需要保存路径；...
【PAT】Dijkstra+最短路径种数（★）+输出路径+卡内存
芒果街上的小屋（此博客暂时停用）
08-02 1835
在求最短路径种数的时候，是这样写的： #include using namespace std; int n,m,ed,a; string st,z,y; map r; struct node{ string a; int b; }x[205]; int w[205][205]; int path[205]; int num[205]; int happy[205]; int cos
PAT：图的最短路径
jinzhao1993的博客
04-16 616
1003 求无向图中最短路径的条数和最大权重和思路：在dj算法的基础上，还要增加两个数组pathNum[]和sum[]。当更新最短路径时，if(dis[j]>(dis[u]+e[u][j])){ dis[j]=(dis[u]+e[u][j]);//正常更新最短路径 pathNum[j]=pathNum[u];//pathNum更新 sum[j]=sum[u]+num[j];/
PAT(甲)-----最短路径题解集
没有期待的日子反而会顺顺利利
11-11 209
原题链接 考察内容：最短路径。 题问：求解最短路径条数和最短路径上的最大点权之和，N (≤500)。 注意点：下标范围0~n-1。 第一标尺距离，因为题目给的点N<=500,所以除了floyd（N<=200）都可以用,个人习惯用vector存的邻接表，点数较少也可以用邻接矩阵存图，下面给出多个解法练个手。 第二标尺是在所有最短路径中选择最优的一条最短路径，关键处理的部分就是最短路径压缩...
PAT最短路径问题简单总结
Nin7a的博客
08-28 376
在PAT甲级真题目录中，涉及到最短路经问题求解的有1003、1018、1030、1087、1111。 一般来说，可以用最短路径算法（dijkstra、SPFA等）加上DFS进行求解。 我一般用这些数据结构： struct node{ int v;//与该地点相连的地点的序号 int cost;//两个地点之间的距离 //...由题意确定需要增加变量 node...
PAT-关于最短路径-Dijkstra+(DFS)
valcanoshan的博客
07-18 406
求单源或全局最短路径（无负边）-> 用Dijkstra： #include <iostream> const int inf = 999999999; cosnt int maxn = 500; int main(){ int e[maxn][maxn],dis[maxn]; fill(e[0],e[0]+maxn*maxn,inf); fill(...
pat最短路径-dj
qq_43543296的博客
03-28 195
pat最短路径最短路径分析难度：P1003P1018P1030P1072小结 最短路径 1003. Emergency (25)-PAT甲级真题（Dijkstra算法） 1018. Public Bike Management (30)-PAT甲级真题（Dijkstra + DFS） 1030. Travel Plan (30)-PAT甲级真题（Dijkstra + DFS，输出路径，边权） 1072. Gas Station (30)-PAT甲级真题（Dijkstra） 1087. All Roads L
PAT刷题——图的最短路径(Dijstra)
sherpahu的博客
05-09 119
PAT1003 Dijstra #include <bits/stdc++.h> using namespace std; const int MAXN=510; int n,m,st,ed,G[MAXN][MAXN],weight[MAXN]; int d[MAXN],w[MAXN],num[MAXN]; bool vis[MAXN]; const int INF=1000000000; void dijstra(int s){ fill(d,d+MAXN,INF); memset(nu
pat数据结构期中模拟2021
09-10
这些问题可能涉及到树的遍历、图的最短路径算法、队列或栈的应用等等。学生需要在规定的时间内完成所有的题目，并给出正确的答案。 为了在考试中取得好的成绩，学生应该提前进行充分的复习和准备。他们可以回顾数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值