【2021天梯赛】L2-L3补题记录

最新推荐文章于 2025-03-12 17:09:56 发布
最新推荐文章于 2025-03-12 17:09:56 发布
阅读量1k 收藏 7
点赞数 8
分类专栏： 天梯赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45660232/article/details/116209880
版权
本文作者分享了首次参与编程天梯赛的体验，虽然感到比赛难度适中，但因一题卡关导致未能获得预期成绩。文章回顾了解题思路，包括病毒溯源、包装机、清点代码库、哲哲打游戏等题目，提供了C++代码解决方案，并对部分题目进行了策略分析和优化。此外，还提及了还原文件这一难题的解题策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章检索器

赛后感想

据说今年的天梯赛比以往简单，咱也不知道，没啥感觉，第一次参加天梯赛，所以并不晓得以往正式赛难度如何，反正我这次是失败告终了，难受啊，本来拿个个人三等应该是势在必得的，遇到病毒之后惨了，强行卡了一个多小时，斩获0分😶。哎，，不说了，都是辛酸泪啊。。。菜鸡流泪😭。

赛后补题

那就先来解决病毒溯源这个毒瘤吧。
看清题目，看清题目，看清题目。。。
（ps:如果长链不唯一，输出最小序列）

Problem 1 L2-038 病毒溯源（25）

补题传送门
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
解题思路：
就是直接暴力的思路。病毒源只有一个，可以记录顶点的度数来寻找病毒源。找到病毒源之后，用 B F S BFS BFS 求一个单源最长路即可。用 f a [ i ] fa[i] fa[i]数组来记录第 i i i 个节点的父亲节点。根据父亲节点与子节点之间的关系，逆向寻找路径，用二维 v e c t o r vector vector 数组记录所有可行方案，再来个排序输出第一个即为最终答案。

C++ AC代码：

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
using namespace std;
vector<int> v[10010];
int d[10010], dist[10010], fa[10010];
vector<vector<int> > res;
int ans, root;
bool vis[10010];
void bfs()
{
	queue<int> q;
	q.push(root);
	dist[root] = 1;
	while (q.size())
	{
		int u = q.front();q.pop();
		for (int i = 0;i < v[u].size();i++)
		{
			int j = v[u][i];
			if (dist[j] < dist[u] + 1)
			{
				dist[j] = dist[u] + 1;
				fa[j] = u;
				q.push(j);
			}
		}
	}
}
bool cmp(vector<int> x, vector<int> y)
{
	for (int i = 0;i < x.size();i++)
	{
		if (x[i] != y[i]) return x[i] < y[i];
	}
}
int main()
{
	int n; scanf("%d", &n);
	for (int i = 0;i < n;i++)
	{
		int k; scanf("%d", &k);
		d[i]++;
		for (int j = 0;j < k;j++)
		{
			int x; scanf("%d", &x);
			v[i].push_back(x);
			d[x]++;
		}
	}
	while (d[root] != 1) root++;
	bfs();
	fa[root] = root;
	int pos;
	for (int i = 0;i < n;i++)
	{
		ans = max(ans, dist[i]);
	}
	printf("%d\n", ans);
	for (int i = 0;i < n;i++)
	{
		if (dist[i] == ans)
		{
			vector<int> tmp;
			int rt = i;
			while (fa[rt] != rt)
			{
				tmp.push_back(rt);
				rt = fa[rt];
			}
			tmp.push_back(root);
			reverse(tmp.begin(), tmp.end());
			res.push_back(tmp);
		}
	}
	sort(res.begin(), res.end(), cmp);
	for (int i = 0;i < res[0].size();i++)
	{
		printf("%d", res[0][i]);
		if (i < res[0].size() - 1) printf(" ");
	}
	return 0;
}

Problem 2 L2-037 包装机（25）

补题传送门
这个题是个简单的队列与栈的操作，不做过多解释，直接放上我的代码吧。

C++ AC代码

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
using namespace std;
queue<char> q[110];
int op[100010];
char st[110];//框
int s;
int main()
{
	int N, M, S; cin >> N >> M >> S;
	for (int i = 1;i <= N;i++)
	{
		string str; cin >> str;
		for (int j = 0;j < str.size();j++) q[i].push(str[j]);
	}
	M = 0;
	while (1)
	{
		int x; cin >> x;
		if (x == -1) break;
		op[++M] = x;
	}
	vector<char> res;//传送带上物品
	for (int i = 1;i <= M;i++)
	{
		int k = op[i];
		if (k == 0)
		{
			if (s) res.push_back(st[s--]);
		}
		else {
			if (q[k].empty()) continue;
			if (s < S){
				st[++s] = q[k].front();q[k].pop();
			}
			else {
				res.push_back(st[s--]);
				st[++s] = q[k].front();q[k].pop();
			}
		}
	}
	for (int i = 0;i < res.size();i++)
	{
		cout << res[i];
	}
	return 0;
}

Problem 3 L2-039 清点代码库（25）

补题传送门
在这里插入图片描述
在这里插入图片描述
解题思路：
这个题还真就长见识了，两个 v e c t o r vector vector 容器可以直接比较大小，比较规则是从前往后遍历每一个元素，返回第一个不相等的元素的比较结果。可以放进 s e t set set 中，也可以放进 m a p map map 中。这样的话，就很好操做了。一开始我使用 m a p map map 记录出现的次数,利用 s e t set set 去重,但可能是卡 m a p map map 了，只能得到 21 21 21 分。得到满分的做法是先排序，相同的就会在相邻的位置，从前往后遍历，记录出现次数，用结构体存储可以比较方便的实现排序及计数。
注意：这个题会卡 c i n cin cin 和 c o u t cout cout.

C++ Score 25:

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
using namespace std;
vector<vector<int> > v;
struct node {
	int sum;
	vector<int> tmp;
}st[10010];
int s;
bool cmp(node x, node y)
{
	if (x.sum != y.sum) return x.sum > y.sum;
	else return x.tmp < y.tmp;
}
int main()
{
	int n, m; scanf("%d%d", &n, &m);
	for (int i = 0;i < n;i++)
	{
		vector<int> tmp;
		for (int j = 0;j < m;j++)
		{
			int x; scanf("%d", &x);
			tmp.push_back(x);
		}
		v.push_back(tmp);
	}
	sort(v.begin(), v.end());
	st[++s] = { 1,v[0] };
	for (int i = 1;i < n;i++)
	{
		if (v[i] != v[i - 1])
		{
			st[++s] = { 1,v[i] };
		}
		else st[s].sum++;
	}
	sort(st + 1, st + s + 1, cmp);
	printf("%d\n", s);
	for (int i = 1;i <= s;i++)
	{
		printf("%d", st[i].sum);
		for (int j = 0;j < st[i].tmp.size();j++)
		{
			printf(" %d", st[i].tmp[j]);
		}
		if (i < s) printf("\n");
	}
	return 0;
}

C++ Score 21:

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
using namespace std;
vector<int> v[10010];
map<vector<int>, int> mp;
set<vector<int> > s;
bool cmp(vector<int> x, vector<int> y)
{
	if (mp[x] != mp[y]) return mp[x] > mp[y];
	return x < y;
}
int main()
{
	int n, m; scanf("%d%d",&n,&m);
	for (int i = 0;i < n;i++)
	{
		for (int j = 0;j < m;j++)
		{
			int x; scanf("%d",&x);
			v[i].push_back(x);
		}
		mp[v[i]]++;
		s.insert(v[i]);
	}
	vector<vector<int> > res;
	for (auto item : s) {
		res.push_back(item);
	}
	sort(res.begin(), res.end(), cmp);
	/*for (int i = 0;i < res.size();i++)
	{
		for (int j = 0;j < res[i].size();j++)
		{
			cout << res[i][j] << " ";
		}
		cout << endl;
	}*/
	printf("%d\n",res.size());
	for (int i = 0;i < res.size();i++)
	{
		printf("%d",mp[res[i]]);
		for (int j = 0;j < res[i].size();j++)
		{
			printf(" %d",res[i][j]);
		}
		if (i < res.size() - 1) printf("\n");
	}
	return 0;
}

Problem 4 L2-040 哲哲打游戏（25）

补题传送门
阅读理解题，按照题目描述模拟就OK，so easy 呀。无语了，当时就应该先开这个题的，策略问题，当时看到题目描述有点长，就习惯性的略过了，直接留到了后面，然而到后面之后根本没心思冷静下来读题，难受。

C++ Score 25:

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
using namespace std;
const int N = 100010;
vector<int> v[N];
int mark[N];
int main()
{
	int n, m; scanf("%d%d", &n, &m);
	for (int i = 1;i <= n;i++)
	{
		int k; scanf("%d", &k);
		v[i].push_back(0);
		for (int j = 1;j <= k;j++)
		{
			int x;scanf("%d", &x);
			v[i].push_back(x);
		}
	}
	int now = 1;
	while (m--)
	{
		int op, x; scanf("%d%d", &op, &x);
		if (op == 1)
		{
			mark[x] = now;
			printf("%d\n",mark[x]);
		}
		else if(op == 0){
			now = v[now][x];
		}
		else if (op == 2)
		{
			now = mark[x];
		}
	}
	printf("%d", now);
	return 0;
}

Problem 5 L3-029 还原文件（30）

补题传送门
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
解题思路：
1、非满分做法，直接暴力，就像字符串匹配那样，只要遇到第一个与当前纸片匹配的片段，就记录一下匹配的位置。之后按照位置排序，输出即可，骗分大法好，这样暴力直接白嫖26分，也是蛮不错滴。
2、满分做法真的没想到，竟然可以直接爆搜，而且还是跑的非常快的那种。听了y总的直播讲解后，恍然大悟啊。数据范围不是很大，有且仅存在一个解，所以直接 d f s dfs dfs 搜索即可，若当前片段能够和原串匹配，记录位置，搜索下一个片段。快速判断两个片段是否匹配时，需要用到字符串哈希的知识。代码实现不算很难，下面放上我的30分代码。

C++ Score 30:

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef unsigned long long ull;
const int N = 100010,M = 110;
const int P = 131;
ull h[N],p[N];
ull g[M];//存储m个小碎片的哈希值
int width[M];//存储小碎片的宽度
int n,m;
ull get_hash(int l,int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}
bool vis[N];
int ans[M];
void dfs(int t,int start)//开始匹配的起点
{
    if(t > m){
        for(int i = 1;i <= m;i++)
        {
            printf("%d",ans[i]);
            if(i < m) printf(" ");
        }
        return;
    }
    for(int i = 1;i <= m;i++)
    {
        if(!vis[i] && g[i] == get_hash(start,start + width[i] - 1))
        {
            vis[i] = true;
            ans[t] = i;
            dfs(t + 1,start + width[i] - 1);
            vis[i] = false;
            ans[t] = 0;
        }
    }
}
int main()
{
    p[0] = 1;
    scanf("%d",&n);
    for(int i = 1;i <= n;i++)
    {
        int x; scanf("%d",&x);
        p[i] = p[i - 1] * P;
        h[i] = h[i - 1] * P + x + 1;
    }
    scanf("%d",&m);
    for(int i = 1;i <= m;i++)
    {
        int len; scanf("%d",&len);
        width[i] = len;
        for(int j = 1;j <= len;j++)
        {
            int x; scanf("%d",&x);
            g[i] = g[i] * P + x + 1;
        }
    }
    dfs(1,1);
    return 0;
}

C++ Score 26:

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
using namespace std;
const int N = 100010;
int a[N], n;
struct node {
	int id;
	int xh;
	vector<int> v;
}st[N];
void deal(node& x)
{
	for (int i = x.v.size();i <= n;i++)
	{
		bool flag = true;
		for (int j = 0;j < x.v.size();j++)
		{
			if (x.v[j] != a[i - x.v.size() + j + 1])
			{
				flag = false;
				break;
			}
		}
		if (flag)
		{
			x.id = i;
			return;
		}
	}
}
bool cmp(node x, node y)
{
	return x.id < y.id;
}
int main()
{
	scanf("%d", &n);
	for (int i = 1;i <= n;i++) scanf("%d", &a[i]);
	int m; scanf("%d", &m);
	for (int i = 1;i <= m;i++)
	{
		int num; scanf("%d", &num);
		vector<int> tmp;
		for (int j = 1;j <= num;j++)
		{
			int x; scanf("%d", &x);
			tmp.push_back(x);
		}
		st[i] = { i,i,tmp };
		deal(st[i]);
	}
	sort(st + 1, st + m + 1, cmp);
	for (int i = 1;i <= m;i++)
	{
		printf("%d", st[i].xh);
		if (i < m) printf(" ");
	}
	return 0;
}

更新ing。。。
最近更新时间：2021.4.29.00:11✌

（每日一题）CF1139D Steps to One && 2021年天梯赛 L3-3 可怜的简单题（期望，莫比乌斯反演，杜教筛）
繁凡さん的博客
05-10 2490
整理的算法模板合集： ACM模板 点我看算法全家桶系列！！！ 实际上是一个全新的精炼模板整合计划 一周连考三门，人都没了 Weblink 2021年天梯赛 L3-3 可怜的简单题 CF1139D Problem Solution 数据较大，要用快速乘不然会爆 long long Code #include <bits/stdc++.h> using namespace std; #define ll long long const int N = 21544400 + 7; #de
2021天梯赛L2-038 病毒溯源(DFS)
qq_43738331的博客
04-26 3776
病毒容易发生变异。某种病毒可以通过突变产生若干变异的毒株，而这些变异的病毒又可能被诱发突变产生第二代变异，如此继续不断变化。 现给定一些病毒之间的变异关系，要求你找出其中最长的一条变异链。 在此假设给出的变异都是由突变引起的，不考虑复杂的基因重组变异问题 —— 即每一种病毒都是由唯一的一种病毒突变而来，并且不存在循环变异的情况。 输入格式： 输入在第一行中给出一个正整数 N（≤10 ​4 ​​ ），即病毒种类的总数。于是我们将所有病毒从 0 到 N−1 进行编号。 随后 N 行，每行按以下格式描述一种病.
天梯赛补题
jyyyyx的算法之旅
04-21 968
天梯赛
天梯赛 L2 & L3 排爆总结
wr114514的博客
03-12 356
说了一下我在做 L2 和 L3 过程中遇到的一些坑。如果你在做天梯赛 L2/L3 系列赛题的过程中被某些测试数据 hack，并且百思不得其解，不妨看看这篇文章。
2021天梯赛补题
Asunayi的博客
05-03 267
文章目录感想1. L1-82. L2-23. L2-34. L3-15. L3-2 感想 今年大家分数都很高，好多230+，然而我只有209（菜鸡流泪 去年拿了145是学校中游水平，今年仍然是中游QAQ，复盘一下大概就是状态不好+平常训练不注意细节（谁叫你天天玩的啊喂 不能说哪一道题有特别大的问题，但是每一道都出了点小问题叭，就内个拿不了全分，不说了，时隔两周我终于补题了 1. L1-8 L1-078 吉老师的回归 (15 分) 当时只拿了13分，不知道哪错了。妈耶，现在回头一看这么简单，当时可能是拿脚写的
天梯赛补题 - 树的同构
yxmGo
03-19 226
我居然连这种递归不太会写了 直接暴力ASCII值作为下标开点233 注意0 0的情况 #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;set&gt; #inc...
【团体程序设计天梯赛】L2-047锦标赛
whaoe_m的博客
01-31 2112
堆、完全二叉树
2020天梯赛 L2-4 网红点打卡攻略（巨坑，哈密顿回路问题）
qq_43738331的博客
11-29 2187
一个旅游景点，如果被带火了的话，就被称为“网红点”。大家来网红点游玩，俗称“打卡”。在各个网红点打卡的快（省）乐（钱）方法称为“攻略”。你的任务就是从一大堆攻略中，找出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略。 输入格式： 首先第一行给出两个正整数：网红点的个数 N（1<N≤200）和网红点之间通路的条数 M。随后 M 行，每行给出有通路的两个网红点、以及这条路上的旅行花费（为正整数），格式为“网红点1 网红点2 费用”，其中网红点从 1 到 N 编号；同时也给出你家到某些网红点的花费，格
天梯赛L2-2 三足鼎立(贪心）
qq_43738331的博客
04-20 1623
当三个国家中的任何两国实力之和都大于第三国的时候，这三个国家互相结盟就呈“三足鼎立”之势，这种状态是最稳定的。 现已知本国的实力值，又给出 n 个其他国家的实力值。我们需要从这 n 个国家中找 2 个结盟，以成三足鼎立。有多少种选择呢？ 输入格式： 输入首先在第一行给出 2 个正整数 n（2≤n≤10 ​5）和 P（≤10 ​9 ​​ ），分别为其他国家的个数、以及本国的实力值。随后一行给出 n 个正整数，表示n 个其他国家的实力值。每个数值不超过 10 ​9 ​​ ，数字间以空格分隔。 输出格式： 在一
【团体程序设计天梯赛】L2-052 吉利矩阵
whaoe_m的博客
04-21 3571
回溯、dfs、剪枝
3.25天梯赛补题（整理板子停留）
weixin_50909982的博客
03-25 159
人以群分 (25 分) 社交网络中我们给每个人定义了一个“活跃度”，现希望根据这个指标把人群分为两大类，即外向型（outgoing，即活跃度高的）和内向型（introverted，即活跃度低的）。要求两类人群的规模尽可能接近，而他们的总活跃度差距尽可能拉开。 输入格式： 输入第一行给出一个正整数N（2≤N≤10​5​​）。随后一行给出N个正整数，分别是每个人的活跃度，其间以空格分隔。题目保证这些数字以及它们的和都不会超过2​31​​。 输出格式： 按下列格式输出： Outgoing #: N1 Introv
天梯赛赛前模拟赛补题—2020
sabr_的博客
11-26 314
一、 畅通工程之最低成本建设问题 这道题是用最小生成树做的，之前最小生成树练的很少，比赛时没写出来，也没考虑用最小生成树，还是练得少。 这个题可以用Kruskal算法做，先将每条路的花费从小到大排序，然后再从头开始加每条边花费的价格，从头开始用并查集判断两个点的根节点是否相同，如果相同说明出现了环，就continue；否则就加上两点之间修一条路的价格。 最后用并查集判断一下是否只有一个连通分量。 #include <iostream> #include <algorithm> #in
天梯赛校赛选拔补题记录
qq_40822492的博客
01-23 186
7-11 奥运排行榜 （25 分） 这个要考虑到并列排名： while(j&gt;0&amp;&amp;qq[j].gp==qq[j-1].gp) --j; 有可能在结构体排序的时候会出现不稳定排序，那么： if(a.gp==gp) return a.no&gt;no;         return a.gp&lt;gp;   7-13 畅通工程之最低成本建设问题 之前的并查集算法忘记了正...
【C++】2024天梯赛补题题解
2303_78842246的博客
04-24 2971
C++写的2024年天梯赛题，当前代码可拿230分
2021级新生程序设计班级天梯赛:2-3 请再一次做我的棋子
心之所向
12-11 823
“世间的事，太痛苦了。我该怎样才能忘却呢？” “下棋吧。” “棋，能代替世间吗？” “能。因为纵横十九道内，栖息着宇宙。” 《王者荣耀》中奕星的大招是画出一个矩形。LT是一个强迫症患者，如果画出来的矩形不是正方形，他就会很难受。现在告诉你奕星大招的四个顶点，请你判断这个矩形是否为正方形。 输入格式: 第一行输入四个整数xi​(0≤xi​≤10000) 第二行输入四个整数yi​(0≤yi​≤10000) 输出格式: 如果矩形是正方形，输出好耶!，否则输出emo！。 输入样例:...
PTA_2021年团体程序设计天梯赛_总决赛_L3-2 还原文件 (30 分)_dfs+回溯
这题AC再睡
03-23 1134
PTA_2021年团体程序设计天梯赛_总决赛_L3-2 还原文件 (30 分)_dfs+回溯
Codeforces Round #548 (Div. 2) 1139 D+2021天梯赛l3-3 解题报告（负二项式分布+莫比乌斯容斥+杜教筛（天梯赛））
nagisa2019的博客
04-30 341
以下是我这道题的思考过程： （1）、若选到1，那直接就能结束了。 （2）、若选到其他的数，则我们需要继续选下去，直到选到一个和前面的一个数互质的数。想到互质，可以想到和质数相关。 思考极限情况，我们可以想象这一过程：不停地选数，在这个过程在，我们保持选到的数的都是某一个数x的倍数，直到选到一个数不为x的倍数就结束。 这一过程其实就是概率论中的负二项式分布: 实验包含一系列独立的实验。 每个实验都有成功、失败两种结果。 成功的概率p是恒定的。 实验持续到r次失败，r可以为任意正数。 则X~NB(r,p
程序设计天梯赛2021年选拔赛L2-3 (什么大模拟+sort)
xianqiuyigedao的博客
03-22 359
题目 题意: 字符串输入输出统计，贼麻烦。 思路: 模拟+sort 时间复杂度: O(nlognlogn)时间复杂度好像写高了，map套set了，不过两个log也T不了，我就不信周老师会个10000*500个全a文章来卡我们大好青年，反正能骗分，虽然现在测不了了。 代码: #include<bits/stdc++.h> using namespace std; #define mem(a,x) memset(a,x,sizeof(a)) #define fir(i,a,b) for(int i=
团队天梯赛L2-001
最新发布
05-07
<think>好的，我现在需要帮助用户查询团队天梯赛L2-001题目的相关信息或解题思路。首先，我要确认用户提到的L2-001具体是哪一年的题目，因为不同年份的题目内容可能不同。用户之前提供的引用内容是关于2021年天梯赛的L1题，但用户现在询问的是L2级别的题目，可能需要更多的信息。 由于用户提供的引用中并没有直接提到L2-001，我需要依靠自己的知识库或查找相关资源。根据常见的L2题目结构，L2-001通常涉及较为复杂的算法或数据结构，比如最短路、动态规划、树结构等。例如，有的年份的L2-001可能是关于紧急救援的问题，涉及Dijkstra算法的应用。 接下来，我需要验证这个假设是否正确。假设题目是紧急救援类问题，通常要求计算最短路径的数量，并在最短路径中选择救援队伍数量最多的路径。解题思路一般包括使用Dijkstra算法，同时维护两个数组：一个记录最短距离，另一个记录最大救援队数量，以及路径数量。 然后，我需要考虑如何结构化回答。首先给出题目的大致描述，然后分步骤解析解题思路，包括图的建立、Dijkstra算法的应用、状态更新的条件等。接着提供示例代码，并确保代码符合用户之前的格式要求，如Python代码块，并正确使用LaTeX公式。 另外，用户要求生成相关问题，我需要根据题目内容提出可能的相关问题，例如如何优化Dijkstra算法、如何处理多个最短路径的情况，以及题目的应用场景等。 最后，检查所有LaTeX公式是否正确使用$...$和$$...$$格式，确保没有语法错误，并确认回答结构清晰，符合用户的要求。</think>### 团队天梯赛 L2-001 紧急救援 题目解析 L2-001通常为**城市紧急救援**类题目，要求计算最短路径数量及最大救援队伍。以下是解题思路： #### 1. 题目核心要素 - 城市构成带权无向图，节点表示城市，边权为路径长度 - 每个城市有救援队伍数量 - 需求：从起点到终点的 - 最短路径条数 - 最短路径中能集结的最大救援队伍 - 具体路径输出 #### 2. 算法选择 采用**Dijkstra算法**变体，维护三个状态数组： - $dist[]$: 最短距离 - $num[]$: 路径数量 - $teams[]$: 最大救援队 - $pre[]$: 前驱节点（用于回溯路径） #### 3. 实现步骤 1. **建图** - 使用邻接表存储：`vector<pair<int, int>> graph[N]` - 记录各城市初始救援队数量 2. **优先队列优化** ```cpp priority_queue<PII, vector<PII>, greater<PII>> pq; // 小顶堆 ``` 3. **状态更新规则** - 当发现更短路径时： $$ dist[v] = dist[u] + w $$ $$ num[v] = num[u] $$ $$ teams[v] = teams[u] + city_teams[v] $$ - 当路径长度相等时： $$ num[v] += num[u] $$ $$ if(teams[u] + city_teams[v] > teams[v]) $$ $$ \quad update\ teams[v]\ and\ pre[v] $$ #### 4. 复杂度分析 - 时间复杂度：$O(M + NlogN)$（优先队列优化版Dijkstra） - 空间复杂度：$O(N+M)$ #### 示例代码框架（C++） ```cpp #include <bits/stdc++.h> using namespace std; const int N=510; int city_teams[N], dist[N], num[N], teams[N], pre[N]; vector<pair<int,int>> graph[N]; void dijkstra(int s, int n){ fill(dist, dist+N, INT_MAX); dist[s] = 0; num[s] = 1; teams[s] = city_teams[s]; // ... 优先队列实现 } void print_path(int v){ if(v == pre[v]) return; print_path(pre[v]); cout << v << " "; } ```
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值