13届蓝桥杯复盘

C++ B组
一直想着复盘的，去年确实很羞耻，什么结果都没有还搭了几百块钱

题D-修建灌木

第一反应想着模拟，但是很明显用代码模拟这个过程过于复杂
然后发现第一次遍历后就是个对称重复的过程，想着这是道数学题
愣是没做出来
事实上这是道观察题？

题解

假设点i刚被修剪完为0，然后会向右/向左跑一趟，端点会被遍历1次，i与端点间的点会被遍历两次
而重新修剪i的当天早上（因为是傍晚修剪，所以当天也会被算上）达到最大高度，然后置零
也就是说：最大长度=中间节点数*2+1（端点）+1（自生）==max(左边/右边节点数)*2
左边端点数：i-1
右边端点数：n-i
代码就一行：

题E-X进制减法

考虑两个数字位数不一致的情况，已知A>=B，所以B的位数不会大于A
我发现我题都读不懂？！这个莫名其妙的数转十进制怎么转的？

// 好吧，比如这个
// 11进制、5进制、2进制
// 10 4 0
// 对于i位上的数字num[i]，转换为十进制就是num[i]*低于i位所有位的进制
// 就是10*5*2+4*2+0=108

我想得好复杂，模拟这个过程，确定每一位的进制（对应位较大的数+1），然后去遍乘低位的进制，还要考虑两个数组位数不一致的问题…
我硬写了一个很繁琐的，还是过不了

int main() {
 
	int maxN, m, n;
	cin >> maxN >> m;
	vector<int> numsA(m);
	for (int i = m-1; i >=0; i--) cin >> numsA[i];
	cin >> n;
	vector<int> numsB(n);
	for (int j = n-1; j >=0; j--) cin >> numsB[j];
 
	// 由低到高计算出每一位的进制
	vector<int> weight(max(m, n));
	int i;
	for (i = 0; i < min(m, n); i++) weight[i] = max(max(numsA[i], numsB[i])+1, 2);
	while (i < m) {
		weight[i] = max(numsA[i] + 1, 2);
		i++;
	}
	while (i < n) {
		weight[i] = max(numsB[i] + 1, 2);
		i++;
	}
 
	// for (int i : weight) cout << i << " ";
 
	long long ans=0,base =1;
	int j;
	for (j = 0; j < min(m, n); j++) {
		ans+= abs(numsA[j] - numsB[j]) * base;
		base *= weight[j];
	}
 
	while (j < m) {
		ans += numsA[j] * base;
		base *= weight[j];
		j++;
	}
	while (j < n) {
		ans += numsB[j] * base;
		base *= weight[j];
		j++;
	}
 
	cout << ans % MOD;
 
	return 0;
}

改-AC代码

补一下取模的运算规则，因为分步计算的过程中频繁出现了越界问题

1. (a + b) % p = (a % p + b % p) % p
2. (a - b) % p = (a % p - b % p) % p
3. (a * b) % p = (a % p * b % p) % p
4. a ^ b % p = ((a % p)^b) % p

#include<iostream>
using namespace std;
const int N = 1e5 + 5;
const long long MOD = 1000000007;
 
int numsA[N], numsB[N];
 
int main() {
 
	int maxN, m, n;
	cin >> maxN >> m;
	for (int i = m - 1; i >= 0; i--) cin >> numsA[i];
	cin >> n;
	for (int j = n - 1; j >= 0; j--) cin >> numsB[j];
 
	long long ret = 0, base = 1;
	int weight;
	for (int i = 0; i < max(m, n); i++) {
		weight = max(max(numsA[i], numsB[i]) + 1, 2);
		// 多项式相加取模是符合分配律的，见公式
		ret = (ret+(numsA[i] - numsB[i]) * base)%MOD;
		base = (base*weight)%MOD;
	}
	cout << ret % MOD;
	return 0;
}