第十四届蓝桥杯省赛c/c++大学B组题解

第十四届蓝桥杯省赛c/c++大学B组题解

个人答案，有错漏感谢指正哈

试题 A: 日期统计

本题总分：5 分
【问题描述】
  小蓝现在有一个长度为 100 的数组，数组中的每个元素的值都在 0 到 9 的
范围之内。数组中的元素从左至右如下所示：
5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2
7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1
0 0 9 4 8 0 9 1 2 8 5 0 2 5 3 3
现在他想要从这个数组中寻找一些满足以下条件的子序列：

1. 子序列的长度为 8；
2. 这个子序列可以按照下标顺序组成一个 yyyymmdd 格式的日期，并且
   要求这个日期是 2023 年中的某一天的日期，例如 20230902，20231223。
   yyyy 表示年份，mm 表示月份，dd 表示天数，当月份或者天数的长度只
   有一位时需要一个前导零补充。
   请你帮小蓝计算下按上述条件一共能找到多少个不同 的 2023 年的日期。
   对于相同的日期你只需要统计一次即可。

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分

【解题思路】
暴力枚举吧！2023前缀剪一下枝，不会很慢的

【代码】

#include
using namespace std;
string s;
int getday[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
set<string> se;//相同日期过滤 
void dfs(string ss,int i){
	if(ss.size()==8){
		int year=stoi(ss.substr(0,4)); 
		int month=stoi(ss.substr(4,2)); 
		int day=stoi(ss.substr(6,2)); 
		if(year==2023){
			if(month>=1&&month<=12){
				if(day>=1&&day<=getday[month]){
					se.insert(ss);
				}
			}
		}
		return;//8个字符后面就没必要了 
	} 
	
	if(i==s.size())return;//深搜完成，退出 
	if(ss.size()==1&&ss.back()!='2')return;//年份不符合条件，直接退出
	if(ss.size()==2&&ss.back()!='0')return;//年份不符合条件，直接退出
	if(ss.size()==3&&ss.back()!='2')return;//年份不符合条件，直接退出
	if(ss.size()==4&&ss.back()!='3')return;//年份不符合条件，直接退出
	if(ss.size()==5&&stoi(ss.substr(4,1))>1)return;//月份不符合条件，直接退出 
	if(ss.size()==6&&(stoi(ss.substr(4,2))>12||stoi(ss.substr(4,2))==0))return;//月份不符合条件，直接退出 
	if(ss.size()==7&&(stoi(ss.substr(6,1))>3))return;//日不符合条件，直接退出 
	if(ss.size()==8&&(stoi(ss.substr(6,2))>31||stoi(ss.substr(6,2))==0))return;//月份不符合条件，直接退出 
	dfs(ss,i+1);//不选当前字符 
	ss+=s[i];
	dfs(ss,i+1);//选择当前字符 
}

int main(){
	string s1 = "5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1 0 0 9 4 8 0 9 1 2 8 5 0 2 5 3 3";
	for(int c:s1){//过滤空格 
		if(c!=' '){
			s+=c;
		}
	}
	dfs("",0);
	cout<<se.size();
} 

【答案】

235

应该是235吧？

试题 B: 01 串的熵

本题总分：5 分
【问题描述】
  对于一个长度为 n 的 01 串 S = x1 x2 x3…xn，香农信息熵的定义为 H(S ) =$-{\sum }_1^{n}p(x_i)lo{g}_2(p(x_i))$，其中 p(0), p(1) 表示在这个 01 串中 0 和 1 出现的占比。比如，对于 S = 100 来说，信息熵 H(S ) = $-\frac{1}{3}lo{g}_2(\frac{1}{3})-\frac{2}{3}lo{g}_2(\frac{2}{3})--\frac{2}{3}lo{g}_2(\frac{2}{3})$=1.3083。对于一个长度为 23333333 的 01 串，如果其信息熵为 11625907.5798，且 0 出现次数比 1 少，那么这个 01 串中 0 出现了多少次？

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【解题思路】
暴力枚举吧！枚举答案即可，题目看着吓人，实则白送5分

【代码】

#include
using namespace std;
int main(){
	for(int i=0;i<=23333333;i++){
		double ans = -(double)i*i/23333333*log((double)i/23333333)/log(2)-(23333333.0-i)*(23333333-i)/23333333*log((23333333.0-i)/23333333)/log(2);
//		cout<
		if(abs(ans-11625907.5798)<1e-4){
			cout<<i<<endl;
			break;
		}
	}
} 

【运行结果】

11027421

试题 C: 冶炼金属

时间限制: 1.0s 内存限制: 256.0MB 本题总分：10 分

【问题描述】
  小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。
  现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。
根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是
多少，题目保证评测数据不存在无解的情况。

【输入格式】
第一行一个整数 N，表示冶炼记录的数目。
接下来输入 N 行，每行两个整数 A、B，含义如题目所述。

【输出格式】
输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。

【样例输入】

3
75 3
53 2
59 2

【样例输出】

20 25

【样例说明】
  当 V = 20 时，有：⌊$\frac{75}{20}$ ⌋ = 3，⌊$\frac{53}{20}$ ⌋ = 2，⌊$\frac{59}{20}$⌋ = 2，可以看到符合所有冶炼
记录。
  当 V = 25 时，有：⌊$\frac{75}{25}$ ⌋ = 3，⌊$\frac{53}{25}$ ⌋ = 2，⌊$\frac{59}{25}$⌋ = 2，可以看到符合所有冶炼
记录。
  且再也找不到比 20 更小或者比 25 更大的符合条件的 V 值了。

【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ N ≤ 10²。
对于 60% 的评测用例，1 ≤ N ≤ 10³。
对于 100% 的评测用例，1 ≤ N ≤ 10⁴，1 ≤ B ≤ A ≤ 10⁹。

【解题思路】
题目意思就是让每种金属都必须炼制出B个特殊金属，多一个少一个都不行，枚举速率的话是一个抛物线形状。答案只有速率太低，速率合适，速率太高，只需要二分枚举速率，特殊地取上下边界即可，

【代码】

#include
using namespace std;
int n;
long long a[10010];
long long b[10010];
vector<vector<long long>> ve;
int check(long long v){
	for(int i=0;i<n;i++){
		if(a[i]/v<b[i]){
			return 2;//速率太慢，需要加快，注意速率越快v的值应该越小 
		}else if(a[i]/v>b[i]){
			return 0;//速率太快，需要减慢
		}
	}
	return 1;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i]>>b[i];
	}
	long long ans1=0,ans2=0;
	long long l=0,r=1e10;//r大一点比较稳 
	while(l<r){
		long long m=(l+r)/2;
		if(check(m)==2){
			r=m-1;
		}else if(check(m)==1){//取左边界 
			r=m;
		}else{
			l=m+1;
		} 
	}
	ans1=l;
	
	l=0,r=1e10;//r大一点比较稳 
	while(l<r){
		long long m=(l+r)/2+1;
		if(check(m)==2){
			r=m-1;
		}else if(check(m)==1){//取右边界 
			l=m;
		}else{
			l=m+1;
		} 
	}
	ans2=l;
	cout<<ans1<<' '<<ans2<<endl;
}

试题 D: 飞机降落

时间限制: 2.0s 内存限制: 256.0MB 本题总分：10 分

【问题描述】

  N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早
可以于 T_i 时刻开始降落，最晚可以于 T_i + Di_i时刻开始降落。降落过程需要 L_i个单位时间。
  一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。
  请你判断 N 架飞机是否可以全部安全降落。

【输入格式】
输入包含多组数据。
第一行包含一个整数 T，代表测试数据的组数。
对于每组数据，第一行包含一个整数 N。
以下 N 行，每行包含三个整数：T_i，D_i 和 L_i。

【输出格式】
对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。

【样例输入】

2
3
0 100 10
10 10 10
0 2 20
3
0 10 20
10 10 20
20 10 20

【样例输出】

YES
NO

【样例说明】
  对于第一组数据，可以安排第 3 架飞机于 0 时刻开始降落，20 时刻完成降
落。安排第 2 架飞机于 20 时刻开始降落，30 时刻完成降落。安排第 1 架飞机
于 30 时刻开始降落，40 时刻完成降落。
  对于第二组数据，无论如何安排，都会有飞机不能及时降落。

【评测用例规模与约定】
对于 30% 的数据，N ≤ 2。
对于 100% 的数据，1 ≤ T ≤ 10，1 ≤ N ≤ 10，0 ≤ T_i, D_i, L_i ≤ 105。

【解题思路】
看数据，N最多为10，时间2秒钟，盲猜暴力题，全排列所有的可能即可，复杂度O(10!*10)，不会超时吧。。。

【代码】

#include
using namespace std;
long long t[15],d[15],l[15];
int n;
int check(){
	int p[10]={0,1,2,3,4,5,6,7,8,9};
	do{
		long long time=0;
		int f=1;
		for(int i=0;i<n;i++){
			if(time>t[p[i]]+d[p[i]]){//这架飞机已经无法起飞，退出 
				f=0;
				break;
			}else{//更新这架飞机起飞完成时间 
				time=max(time,t[p[i]])+l[p[i]];
			}
		}
		if(f==1)return 1;
	}while(next_permutation(p,p+n));
	return 0;
}
int main(){
	int tt;
	cin>>tt;
	while(tt--){
		cin>>n;
		for(int i=0;i<n;i++){
			cin>>t[i]>>d[i]>>l[i];
		}
		if(check()){
			cout<<"YES"<<endl;
		}else{
			cout<<"NO"<<endl; 
		}
	}
}

试题 E: 接龙数列

时间限制: 1.0s 内存限制: 256.0MB 本题总分：15 分

【问题描述】
  对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。
  例如 12, 23, 35, 56, 61, 11 是接龙数列；12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。
  现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少
个数，可以使剩下的序列是接龙序列？

【输入格式】
第一行包含一个整数 N。
第二行包含 N 个整数 A1, A2, . . . , AN。

【输出格式】
一个整数代表答案。

【样例输入】

5
11 121 22 12 2023

【样例输出】

1

【样例说明】
删除 22，剩余 11, 121, 12, 2023 是接龙数列。

【评测用例规模与约定】
对于 20% 的数据，1 ≤ N ≤ 20。
对于 50% 的数据，1 ≤ N ≤ 10000。
对于 100% 的数据，1 ≤ N ≤ 10₅，1 ≤ A_i ≤ 10₉。所有 A_i 保证不包含前导 0。

【解题思路】
动态规划，记录以某个字母结尾的最优解即可，例如样例，
i=0时，11，字母1结尾的接龙数列最长为1
i=1时，121 ，字母1结尾的接龙数列最长为2
i=2时，22 ，字母2结尾的接龙数列最长为1
i=3时，12，字母2结尾的接龙数列最长为3
i=4时，2023，字母3结尾的接龙数列最长为4
答案为n-最长的接龙序列，即5-4=1

【代码】

#include
using namespace std;
int main(){
	int l[10]={0};
	int n;
	cin>>n;
	int ma=0;
	for(int i=0;i<n;i++){
		string s;
		cin>>s;
		l[s.back()-'0']=max(l[s.back()-'0'],l[s[0]-'0']+1);
		ma=max(ma,l[s.back()-'0']);
	}
	cout<<n-ma<<endl;
}

试题 F: 岛屿个数

时间限制: 2.0s 内存限制: 256.0MB 本题总分：15 分

【问题描述】
  小蓝得到了一副大小为 M × N 的格子地图，可以将其视作一个只包含字符‘0’（代表海水）和 ‘1’（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的 ‘1’ 相连接而形成。在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(x₀, y₀),(x₁, y₁), . . . ,(x_k−1, y_k−1)，其中(x_(i+1)%k, y_(i+1)%k) 是由 (x_i, y_i) 通过上/下/左/右移动一次得来的 (0 ≤ i ≤ k − 1)，此时这 k 个格子就构成了一个 “环”。如果另一个岛屿 B 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 B 视作是岛屿 A 的子岛屿。若 B 是 A 的子岛屿，C 又是 B 的子岛屿，那 C 也是 A 的子岛屿。
  请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。

【输入格式】
  第一行一个整数 T，表示有 T 组测试数据。
  接下来输入 T 组数据。对于每组数据，第一行包含两个用空格分隔的整数
M、N 表示地图大小；接下来输入 M 行，每行包含 N 个字符，字符只可能是
‘0’ 或 ‘1’。

【输出格式】
对于每组数据，输出一行，包含一个整数表示答案。

【样例输入】

2
5 5
01111
11001
10101
10001
11111
5 6
111111
100001
010101
100001
111111

【样例输出】

1
3

【样例说明】
对于第一组数据，包含两个岛屿，下面用不同的数字进行了区分：

01111
11001
10201
10001
11111

岛屿 2 在岛屿 1 的 “环” 内部，所以岛屿 2 是岛屿 1 的子岛屿，答案为 1。
对于第二组数据，包含三个岛屿，下面用不同的数字进行了区分：

111111
100001
020301
100001
111111

注意岛屿 3 并不是岛屿 1 或者岛屿 2 的子岛屿，因为岛屿 1 和岛屿 2 中均没有
“环”。

【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ M, N ≤ 10。
对于 100% 的评测用例，1 ≤ T ≤ 10，1 ≤ M, N ≤ 50。

【解题思路】
我做得挺麻烦的，应该有更好的解题思路哈哈
1、0可以往八个方向扩张，如果0能到的地方，那么就一定不是子岛屿。
2、1只能向上下左右四个方向扩张，并且只能扩张到为1的区域，这样能保证第一点的正确性
3、解决记录岛屿的问题–使用并查集，避免重复计算，也减去了大量的判断
4、可以先在图的外层添加一层0，这样从(0,0)点开始bfs就可以了！

【代码】

#include
using namespace std;
int f[5010];
int g1[4][2]={0,1,1,0,-1,0,0,-1};//上下左右四个方向 
int g2[8][2]={0,1,1,0,-1,0,0,-1,1,1,1,-1,-1,-1,-1,1};//八个方向 

int find(int a){//并查集 
	if(f[a]!=a)return f[a]=find(f[a]);
	return a;
}
int main(){
	int t;
	cin>>t;
	while(t--){
		for(int i=0;i<5010;i++){//初始化并查集 
			f[i]=i;
		}
		int n,m;
		cin>>n>>m;
		string s[55];
		for(int i=1;i<=n;i++){
			cin>>s[i];
		}
		for(int i=0;i<=m+1;i++){//外围加一层0 
			s[0]+='0';
			s[n+1]+='0';
		}
		for(int i=1;i<=n;i++){
			s[i]+='0';
			s[i].insert(0,"0");
		}
		n+=2;
		m+=2;
		
		queue<vector<int>> q;
		q.push({0,0});
		int vis[55][55]={1};//标记数组 
		while(!q.empty()){
			vector<int> v = q.front();
			q.pop();
			if(s[v[0]][v[1]]=='1'){//向四个方向扩张，且为1 
				for(int i=0;i<4;i++){
					int x=v[0]+g1[i][0];
					int y=v[1]+g1[i][1];
					if(x>=0&&x<n&&y>=0&&y<m&&s[x][y]=='1'){
						f[find(v[0]*m+v[1])]=find(x*m+y);//连接起来 
						if(vis[x][y]==0){
							q.push({x,y});
							vis[x][y]=1;
						} 
					}
				} 
			}else{//向八个方向扩张 
				for(int i=0;i<8;i++){
					int x=v[0]+g2[i][0];
					int y=v[1]+g2[i][1];
					if(x>=0&&x<n&&y>=0&&y<m){
						if(vis[x][y]==0){
							q.push({x,y});
							vis[x][y]=1;
						} 
					}
				} 
			}
		}
		
		
		long long ans=0;
		//第二次计算答案 
		q.push({0,0});
		memset(vis,0,sizeof vis);
		vis[0][0]=1; 
		while(!q.empty()){
			vector<int> v = q.front();
			q.pop();
			if(s[v[0]][v[1]]=='1'){//向四个方向扩张，且为1 
				if(find(v[0]*m+v[1])==v[0]*m+v[1]){
					ans++;
				}
				for(int i=0;i<4;i++){
					int x=v[0]+g1[i][0];
					int y=v[1]+g1[i][1];
					if(x>=0&&x<n&&y>=0&&y<m&&s[x][y]=='1'){
						if(vis[x][y]==0){
							q.push({x,y});
							vis[x][y]=1;
						} 
					}
				} 
			}else{//向八个方向扩张 
				for(int i=0;i<8;i++){
					int x=v[0]+g2[i][0];
					int y=v[1]+g2[i][1];
					if(x>=0&&x<n&&y>=0&&y<m){
						if(vis[x][y]==0){
							q.push({x,y});
							vis[x][y]=1;
						} 
					}
				} 
			}
		}
		cout<<ans<<endl;
	}
}

试题 G: 子串简写

时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分

【问题描述】
  程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 internation-alization 简写成 i18n，Kubernetes （注意连字符不是字符串的一部分）简写成 K8s, Lanqiao 简写成 L5o 等。
  在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。
  给定一个字符串 S 和两个字符 c₁ 和 c₂，请你计算 S 有多少个以 c₁ 开头
c₂ 结尾的子串可以采用这种简写？

【输入格式】
第一行包含一个整数 K。
第二行包含一个字符串 S 和两个字符 c₁ 和 c₂。

【输出格式】
一个整数代表答案。

【样例输入】

4
abababdb a b

【样例输出】

6

【样例说明】
符合条件的子串如下所示，中括号内是该子串：
[abab]abdb
[ababab]db
[abababdb]
ab[abab]db
ab[ababdb]
abab[abdb]

【评测用例规模与约定】
对于 20% 的数据，2 ≤ K ≤ |S | ≤ 10000。
对于 100% 的数据，2 ≤ K ≤ |S | ≤ 5 × 10⁵。S 只包含小写字母。c₁ 和 c₂ 都是小写字母。|S | 代表字符串 S 的长度。

【解题思路】
计算贡献的题目，记录a的前缀和，当遇到字符b时记录答案即可

【代码】

#include
using namespace std;
int main(){
	int k;
	string s;
	string a,b;
	cin>>k>>s>>a>>b;
	long long sum=0;
	long long ans=0;
	for(int i=k-1;i<s.size();i++){
		if(s[i-(k-1)]==a[0]){
			sum++;
		}
		if(s[i]==b[0]){
			ans+=sum;
		}
	}
	cout<<ans<<endl;
}

试题 H: 整数删除

时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分

【问题描述】
  给定一个长度为 N 的整数数列：A₁, A₂, . . . , A_N。你要重复以下操作 K 次：
每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的），将其删除。并把与它相邻的整数加上被删除的数值。输出 K 次操作后的序列。

【输入格式】
第一行包含两个整数 N 和 K。
第二行包含 N 个整数，A₁, A₂, A₃, . . . , A_N。

【输出格式】
输出 N − K 个整数，中间用一个空格隔开，代表 K 次操作后的序列。

【样例输入】

5 3
1 4 2 8 7

【样例输出】

17 7

【样例说明】
数列变化如下，中括号里的数是当次操作中被选择的数：

[1] 4 2 8 7
5 [2] 8 7
[7] 10 7
17 7

【评测用例规模与约定】
对于 20% 的数据，1 ≤ K < N ≤ 10000。
对于 100% 的数据，1 ≤ K < N ≤ 5 × 10⁵，0 ≤ A_i≤ 10⁸。

【解题思路】
用优先级队列动态地获取最小的数，时间复杂度为O(N*logN)
1、用懒标记标记删除的点，在队列中获取数据时判断是否被标记删除，是则丢弃，否则就是要取的点
2、删除当前节点后，左右节点加上当前节点的值，并且左节点的右节点更新为当前节点的右节点、右节点的左节点更新为当前节点的左节点
模拟这个过程即可

【代码】

#include
using namespace std;
int n,m;
vector<long long> v[500010];//存节点信息 
int f[500010];//标记是否被删除 
int main(){
	priority_queue<vector<long long>,vector<vector<long long>>,greater<vector<long long>>> q;
	cin>>n>>m;
	v[0]=v[n+1]={0,0,0};
	for(long long i=1;i<=n;i++){
		long long a;
		cin>>a;
		v[i]={a,i-1,i+1};//记录值和前后点的位置 
		q.push({a,i});//把值和下标放入优先级队列 
	}
	while(m--){
		while(!q.empty()&&(q.top()[0]!=v[q.top()[1]][0]||f[q.top()[1]]==1)){//被删除的点或者不是最新的点直接丢掉 
			q.pop();
		}
		vector<long long> vv=q.top();
		q.pop();
		f[vv[1]]=1;
		long long l = v[vv[1]][1];//左节点 
		long long r = v[vv[1]][2];//右节点 
		v[l][0]+=vv[0]; //左节点加上当前节点的值 
		v[l][2]=v[vv[1]][2];//左节点的右节点改为当前节点的右节点 
		v[r][0]+=vv[0]; //右节点加上当前节点的值 
		v[r][1]=v[vv[1]][1];//右节点的左节点改为当前节点的左节点 
		if(l>0&&l<=n){//越界判断 
			q.push({v[l][0],l});
		}
		if(r>0&&r<=n){
			q.push({v[r][0],r});
		}
	} 
	int ff=0;//控制输出的空格 
	for(int i=1;i<=n;i++){//打印未删除的节点 
		if(f[i]==0){
			if(ff==1){
				cout<<' ';
			}
			ff=1;
			cout<<v[i][0];
		}
	}
}

试题 I: 景区导游

时间限制: 5.0s 内存限制: 256.0MB 本题总分：25 分

【问题描述】
&emsp 某景区一共有 N 个景点，编号 1 到 N。景点之间共有 N − 1 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。
&emsp小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中 K 个
景点：A₁, A₂, . . . , A_K。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中 K − 1 个景点。具体来说，如果小明选择跳过 Ai，那么他会
按顺序带游客游览 A₁, A₂, . . . , A_i−1, A_i+1, . . . , A_K, (1 ≤ i ≤ K)。
&emsp请你对任意一个 Ai，计算如果跳过这个景点，小明需要花费多少时间在景
点之间的摆渡车上？

【输入格式】
第一行包含 2 个整数 N 和 K。
以下 N − 1 行，每行包含 3 个整数 u, v 和 t，代表景点 u 和 v 之间有摆渡
车线路，花费 t 个单位时间。
最后一行包含 K 个整数 A1, A2, . . . , AK 代表原定游览线路。

【输出格式】
输出 K 个整数，其中第 i 个代表跳过 Ai 之后，花费在摆渡车上的时间。

【样例输入】

6 4
1 2 1
1 3 1
3 4 2
3 5 2
4 6 3
2 6 5 1

【样例输出】

10 7 13 14

【样例说明】
原路线是 2 → 6 → 5 → 1。
当跳过 2 时，路线是 6 → 5 → 1，其中 6 → 5 花费时间 3 + 2 + 2 = 7，
5 → 1 花费时间 2 + 1 = 3，总时间花费 10。
当跳过 6 时，路线是 2 → 5 → 1，其中 2 → 5 花费时间 1 + 1 + 2 = 4，
5 → 1 花费时间 2 + 1 = 3，总时间花费 7。
当跳过 5 时，路线是 2 → 6 → 1，其中 2 → 6 花费时间 1 + 1 + 2 + 3 = 7，
6 → 1 花费时间 3 + 2 + 1 = 6，总时间花费 13。
当跳过 1 时，路线时 2 → 6 → 5，其中 2 → 6 花费时间 1 + 1 + 2 + 3 = 7，
6 → 5 花费时间 3 + 2 + 2 = 7，总时间花费 14。

【评测用例规模与约定】
对于 20% 的数据，2 ≤ K ≤ N ≤ 10²。
对于 40% 的数据，2 ≤ K ≤ N ≤ 10⁴。
对于 100% 的数据，2 ≤ K ≤ N ≤ 10⁵，1 ≤ u, v, A_i ≤ N，1 ≤ t ≤ 10⁵。保证A_i 两两不同。

【解题思路】
使用最近公共祖先算法即可解答该题
1、因为题目给出的是无向树，我们任意拿一个作为树的根节点都可以
2、假如要求a、b两点的距离，假设根节点为root，a、b最近公共祖先是c，那么a点和b点之间的距离等于a点到root的距离加上b点到root的距离减去c点到root的距离的两倍

3、如上面样例画出来的图，求点6到点5的距离 = 点6到点1的距离 + 点5到点1的距离 - 2*点3到点1的距离

4、那么我们就要先预处理出所有点到根节点的距离！

5、接下来求出最小公共祖先即可AC了，求最小公共祖先算法有多种，倍增、树链剖分、tanjar离线都可以做到，这到题5秒钟，都不会超时的吧，下面代码是用tanjar离线做的

【代码】

#include
using namespace std;
vector<vector<long long>> v[100010];
long long d[100010];
void dfs(long long i,long long p,long long dd){//i：当前节点，p：父节点，dd目前的距离 
	d[i]=dd;
	for(vector<long long> c:v[i]){
		if(c[0]!=p){
			dfs(c[0],i,dd+c[1]);
		}
	}
}

long long f[100010];
long long find(long long a){//tanjar离线算法需要使用并查集 
	if(f[a]!=a)return f[a]=find(f[a]);
	return a;
}

int vis[100010];//标记数组 
vector<long long> vvv[100010];//离线的点 
map<pair<long long,long long>,long long> ma;
void dfs2(long long i,long long p){//i：当前节点，p：父节点

	for(long long c:vvv[i]){//记录最近公共祖先 
		if(vis[c]==1){
			ma[{i,c}]=find(c);
			ma[{c,i}]=find(c);
		}
	}

	for(vector<long long> c:v[i]){
		if(c[0]!=p){
			dfs2(c[0],i);
		}
	}
	f[find(i)]=find(p);
	vis[i]=1;
} 

int main(){
	for(int i=0;i<100010;i++){//初始化并查集 
		f[i]=i;
	}
	int n,m;
	cin>>n>>m;
	for(int i=1;i<n;i++){
		long long x,y,val;
		cin>>x>>y>>val;
		v[x].push_back({y,val});
		v[y].push_back({x,val});
	}
	vector<long long> vv;//存原本的路径 
	for(int i=0;i<m;i++){
		long long a;
		cin>>a;
		vv.push_back(a);
	} 
	for(int i=1;i<m;i++){
		vvv[vv[i]].push_back(vv[i-1]);
		vvv[vv[i-1]].push_back(vv[i]);
		if(i>=2){
			vvv[vv[i]].push_back(vv[i-2]);
			vvv[vv[i-2]].push_back(vv[i]);
		}
	} 
	
	dfs(1,0,0);//求出所有点到根节点的距离
	
	dfs2(1,0);//tanjar离线求最小公共祖先 
	
	long long ans=0;//总路线花费 
	for(int i=1;i<vv.size();i++){
		ans+=d[vv[i]]+d[vv[i-1]]-2*d[ma[{vv[i-1],vv[i]}]];
	}
	
	cout<<ans-(d[vv[0]]+d[vv[1]]-2*d[ma[{vv[0],vv[1]}]])<<' ';//特别处理第一个点 
	for(int i=1;i<vv.size()-1;i++){//去掉中间点 
		cout<<(ans-(d[vv[i]]+d[vv[i-1]]-2*d[ma[{vv[i-1],vv[i]}]])-(d[vv[i]]+d[vv[i+1]]-2*d[ma[{vv[i+1],vv[i]}]]))+(d[vv[i-1]]+d[vv[i+1]]-2*d[ma[{vv[i+1],vv[i-1]}]])<<' ';
	}
	cout<<ans-(d[vv.back()]+d[vv[vv.size()-2]]-2*d[ma[{vv.back(),vv[vv.size()-2]}]])<<endl;//特别处理最后一个点 
	
} 

试题 J: 砍树

时间限制: 1.0s 内存限制: 256.0MB 本题总分：25 分

【问题描述】
给定一棵由 n 个结点组成的树以及 m 个不重复的无序数对 (a₁, b₁), (a₂, b₂),. . . , (a_m, b_m)，其中 ai 互不相同，b_i 互不相同，a_i , b_j(1 ≤ i, j ≤ m)。小明想知道是否能够选择一条树上的边砍断，使得对于每个 (ai, b_i) 满足 a_i和 b_i 不连通，如果可以则输出应该断掉的边的编号（编号按输入顺序从 1 开始），否则输出 -1。

【输入格式】
输入共 n + m 行，第一行为两个正整数 n，m。
后面 n − 1 行，每行两个正整数 xi，yi 表示第 i 条边的两个端点。
后面 m 行，每行两个正整数 a_i，b_i。

【输出格式】
一行一个整数，表示答案，如有多个答案，输出编号最大的一个。

【样例输入】

6 2
1 2
2 3
4 3
2 5
6 5
3 6
4 5

【样例输出】

4

【样例说明】
断开第 2 条边后形成两个连通块：{3, 4}，{1, 2, 5, 6}，满足 3 和 6 不连通，4
和 5 不连通。
断开第 4 条边后形成两个连通块：{1, 2, 3, 4}，{5, 6}，同样满足 3 和 6 不连
通，4 和 5 不连通。
4 编号更大，因此答案为 4。

【评测用例规模与约定】
对于 30% 的数据，保证 1 < n ≤ 1000。
对于 100% 的数据，保证 1 < n ≤ 10⁵，1 ≤ m ≤ 2。

最后一题不会嘿嘿嘿