2022.08.10模拟赛总结

总述

分数： $260pts$
$Rank$： $3$
$T1$：$100pts$
$T2$：$100pts$
$T3$：$60pts$
$T4$：$0pts$

题解

T1 数列

看完题就知道是个大水题，%你即可。

每次对于 $S_i$ 而言，遍历 $S_{i-1}$ ，记录其中连续出现的数及次数，加入 $S_i$ 即可。

$Code:$

#include 
using namespace std;

string s[30];

int main() {
	int n;
	scanf("%d", &n);
	s[1] = "1";
	
	for (int i = 2; i <= n; i ++) {
		int tim = 0;
		
		for (int j = 0; j < s[i - 1].size(); j ++) {
			tim ++;
			
			if (j == s[i - 1].size() - 1 || s[i - 1][j] != s[i - 1][j + 1]) {
				s[i] += (char)(tim + '0');
				s[i] += s[i - 1][j];
				tim = 0;
			}
		}
		
	}
	
	cout << s[n];
	return 0;
}

T2 索引

读题后我们发现，本题中$n$的范围很大，但是$k$的范围很小，而且还伴随着区间修改、单点查询的操作，更重要的是，保证a数组时刻保持严格单调递增， 所以我们就有两种做法来写：

做法1 树状数组+二分

时间复杂度：O($k\times lo{g}^{2}n$)

对于区间查询、单点修改，我们可以利用树状数组在$O(logn)$的时间复杂度内对数组的偏移量进行维护，并查询单个数字。

加上二分查找，若$a_i==i$，直接输出$YES$，如果$a_i<i$，$l=mid+1$，否则$r=mid-1$。整体时间复杂度为$O(k\times lo{g}^{2}n)$。

$Code:$

#include //因为是严格单调递增，所以可以二分数列求解
using namespace std;

const int maxn = 1e7 + 5;
int n, k;
int a[maxn], c[maxn];

inline int read() {
	int x = 0, f = 1;
	char ch = getchar();
	
	while (!isdigit(ch)) {
	
		if(ch == '-')
			f = -1;
			
		ch = getchar();
	}
	
	while (isdigit(ch)) {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	
	return x * f;
}

inline int lowbit(int x) {
	return x & (-x);
}

inline void add(int x, int y) {
	while (x <= n) {
		c[x] += y;
		x += lowbit(x);
	}
}

inline int ask(int x) {
	int res = 0;
	
	while (x) {
		res += c[x];
		x -= lowbit(x);
	}
	
	return res;
}

int main() { 
	k = read(), n = read();
	bool flag = 0;
	
	for (int i = 1; i <= n; i ++) {
		a[i] = read();
		
		if(a[i] == i)
			flag = 1;
	}
	
	if(flag)
		puts("YES");
	else
		puts("NO");
		
	for (int i = 1; i < k; i ++) {
		int l = read(), r = read(), num = read();
		add(l, num);
		add(r + 1, -num);
		l = 1, r = n;
		bool flag = 0;
		
		while (l <= r) {
			int mid = (l + r) >> 1;
			int cnt = ask(mid) + a[mid];
			
			if(cnt == mid) {
				puts("YES");
				flag = 1;
				break;
			}
			
			if(cnt < mid)
				l = mid + 1;
			else
				r = mid - 1;
		}
		
		if(!flag)
			puts("NO");
	}
	return 0;
}

做法2 枚举+二分

时间复杂度：O($k^2\times logn$)

因为保证$a$数组严格递增，那么将每个$a_i-i$之后，$a$数组也是单调不降的。

这时，我们可以记录每一次修改的区间，如果二分到的$mid$在这个区间以内，就让$sum$加等于修改的值，最后判断$a_{mid}+sum$是否大于$0$即可，并由此改变二分边界。

$Code:$

#include 
using namespace std;

const int maxn = 1e7 + 5;
const int maxk = 1005;
int k, n;
int a[maxn];
struct my_str {
	int F, S, Val;
}b[maxk];

inline int read() {
	int x = 0, f = 1;
	char ch = getchar();
	
	while (!isdigit(ch)) {
		
		if (ch == '-')
			f = -1;
			
		ch = getchar();
	}
	
	while (isdigit(ch)) {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	
	return x * f;
}

int main() {
	k = read(), n = read();
	bool flag = 0;
	
	for (int i = 1; i <= n; i ++) {
		a[i] = read();
		a[i] -= i;
		
		if(a[i] == 0)
			flag = 1;
	}
	
	if (flag) puts("YES");
	else puts("NO");
	
	for (int i = 1; i < k; i ++) {
		b[i].F = read(), b[i].S = read(), b[i].Val = read();
		int l = 1, r = n;
		flag = 0;
		
		while (l <= r) {
			int mid = (l + r) >> 1;
			int res = 0;
			
			for (int j = 1; j <= i; j ++) {
				
				if (mid >= b[j].F && mid <= b[j].S)
					res += b[j].Val;
					
			}
			
			if (a[mid] + res == 0) {
				puts("YES");
				flag = 1;
				break;
			}
			
			if(a[mid] + res > 0)
				r = mid - 1;
			else l = mid + 1;
		}
		
		if (!flag) puts("NO");
	}
	return 0;
}

T3 奇数

由于本蒟蒻只浅浅了解过分块的基础作用，所以不会本题AC做法……

$60pts$做法：

因为$a_i\le 10$，所以我们可以记录每个数字出现次数的前缀和，查询时遍历$1\sim 10$，判断是否为奇数次即可。

$60Code:$

#include 
using namespace std;

const int maxn = 1e5 + 5;
int n, q;
int a[maxn];
int f[13];
int s[13][maxn];

inline int read() {
	int x = 0, f = 1;
	char ch = getchar();
	
	while (!isdigit(ch)) {
	
		if (ch == '-')
			f = -1;
			
		ch = getchar();
	}
	
	while (isdigit(ch)) {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	
	return x * f;
}

int main() {
	n = read();
	bool flag = 0;
	
	for (int i = 1; i <= n; i ++) {
		a[i] = read();
		
		if(a[i] > 10)
			flag = 1;
	}
	
	q = read();
	//养成分段好习惯
	if (n <= 1e3 && q <= 1e3) {//30pts:暴力枚举区间每个数并记录次数

		for (int i = 1; i <= q; i ++) {
			int l = read(), r = read();
			memset(f, 0, sizeof f);
			
			for (int j = l; j <= r; j ++)
				f[a[j]] ++;
				
			int ans = 0;
			
			for (int j = 1; j <= 10; j ++)
				if(f[j] & 1) ans ++;
				
			printf("%d\n", ans);
		}
		
		return 0;
	}
	else if (!flag) {//30pts
	
		for (int i = 1; i <= n; i ++) {
		
			for (int j = 1; j <= 10; j ++)
				s[j][i] = s[j][i - 1];
				
			s[a[i]][i] ++;
		}
		
		for (int i = 1; i <= q; i ++) {
			int l = read(), r = read();
			int ans = 0;
			
			for (int j = 1; j <= 10; j ++)
				if ((s[j][r] - s[j][l - 1]) & 1)
					ans ++;
					
			printf("%d\n", ans);
		}
		return 0;
	}
	return 0;
}

T4 解谜

看题后发现，本题可以分为两问：第一问为求出节点数为n的不同形态的二叉树的数量，设其为$f_n$。很显然$f_n=Ca{t}_n$。第二问为求出每棵二叉树的叶子结点数量之和。设其为$g_n$。这该怎么求呢？

我们发现：假设一棵具有$n$个节点的二叉树有$k$个叶子结点，那么我们分别将这$k$个叶子结点删去，当好对应了$k$棵节点数为$n-1$的二叉树。也就是说，节点数为n-1的二叉树与节点数为n的二叉树是有对应关系的。

那么，我们就可以通过将节点数为$n-1$的二叉树向外延伸叶子节点的方式来得到所有的节点数为$n$的二叉树。而我们又惊奇的发现：节点数为n-1的二叉树，可以向外延伸的叶子结点数为n。为什么呢？？？证明如下：

每一棵节点数为$n-1$的二叉树，度数为$2\times (n-2)$。此时我们将其所有叶子结点以及其他不满两个儿子的节点全部补成两个儿子，不难发现，此时的总度数为$3\times (n-1)-1$。此时，我们新加的节点数即为$3\times (n-1)-1-2\times (n-2)=n$。

所以，我们也就不难得出结论：$g_n=f_{n-1}\times n$。

最终答案即为$\frac{g_n}{f_n}$。

$Code:(含式子化简)$

#include 
using namespace std;

typedef long long LL;
LL mod = 2148473647;

LL qpow (LL a, LL b) {
	LL ans = 1;
	a = a % mod;
	
	while (b) {
	
		if (b & 1)
			ans = (ans * a) % mod;
			
		a = (a * a) % mod;
		b >>= 1;
	}
	
	return ans % mod;
}

LL gcd (LL a, LL b) {

	if (a < b)
		swap(a, b);
		
	while (b) {
		LL temp = a;
		a = b;
		b = temp % b;
	}
	
	return a;
}

int main() {
	LL n;
	scanf("%lld", &n);
	LL m = 2LL * (2LL * n - 1LL);
	n = (n * (n + 1)) % mod;
	LL GCD = gcd(n, m);
	n /= GCD, m /= GCD;
	m = qpow(m, mod - 2);
	printf("%lld", (n * m) % mod);
	return 0;
}
/*
  g[n] / f[n]
= f[n - 1] * n / f[n]
= ((((2n - 2)! / ((n - 1)! * (n - 1)!))) * (1 / n) * n) / (((2n)! / (n! * n!)) * (1 / (n + 1)))
= (((2n - 2)! / ((n - 1)! * (n - 1)!))) * ((n! * n! * (n + 1)) / (2n)!)
= (n * n * (n + 1)) / (2n * (2n - 1))
= (n * n * (n + 1)) / n * (4n - 2)
= (n * (n + 1)) / 2 * (2n - 1)
f[n]:节点数为n的二叉树的个数
g[n]:节点数为n的二叉树叶子节点个数之和
g[n] = f[n - 1] * n;
*/

总结

今天打的还不错，至少自己认为应该拿到的分数拿到了。

还是有一点，不能放弃思考。T4我要多想会，说不定也能推出来式子呢……

以后继续努力，奋战$CSP-S$吧！！！