pezhzh的快乐寒假作业[2024/1/19]

熬夜的coder没有早上，所以咱们中午才开始看题是正常的！(误)

A - Vacations

洛谷：CF698A；

一道内卷小哥的日程表安排题；

一开始本来想搜索的，但是似乎可以直接贪，所以来分析一下吧~

对于四种情况，我们分别理解成：

0：我们只能休息(卷哥暴哭QAQ)；

1：如果我们前一天没练，那我们就练，如果前一天练了，今天就休息；

2：如果我们前一天没比，那我们就比，如果前一天比了，今天就休息；

3：总是做与前一天相反的行为，但是如果前一天休息，那就做与后一天相反的；

编号为3的前半句很好理解，但后半句实现似乎很怪，所以我们改一种说法：

如果前一天休息，那我的行为不会影响后一天的行为，后一天爱干嘛干嘛；

实现的方式就是我直接休息但是我不计数(偷偷摸了)；

看看程序吧！

#include <bits/stdc++.h>
using namespace std;
int n, a, res, fl;
int main(){
	cin >> n;
	for(int i = 0; i < n; i ++){
		cin >> a;
		if(!a){
			res ++;
			fl = 0;
		}else if(a == 1){
			if(fl == 1){
				fl = 0;
				res ++;
			}else fl = 1;
		}else if(a == 2){
			if(fl == 2){
				fl = 0;
				res ++;
			}else fl = 2;
		}else{
			if(fl == 1) fl = 2;
			else if(fl == 2) fl = 1;
		}
	}
	cout << res;
} 

fl 表示前一天干嘛了；

res记录休了几次(但是3是偷偷休的别人不知道)；

B - Basketball Exercise

洛谷：CF1195C；

同编号的球员最多只能选一个，但是可以不选，求最大身高；

看图可以知道，在确定要选第三行上面那个的情况下，我们的i - 2个分别可以去上或下，于此相对的是我们的i - 1个取下或空；

那么到第（i，j）个球员所选的身高最大值就是由（i - 1，! j）与（i - 2，j）的最大的那个决定的；

看看程序辅助理解：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long n, a[2][N], dp[2][N];
int main(){
	cin >> n;
	for(int i = 0; i < 2; i ++)
	for(int j = 0; j < n; j ++)
	scanf("%d", &a[i][j]);
	dp[0][0] = a[0][0];
	dp[1][0] = a[1][0];
	dp[0][1] = a[0][1] + dp[1][0];
	dp[1][1] = a[1][1] + dp[0][0];
	for(int i = 2; i < n; i ++){
		dp[0][i] = a[0][i] + max(dp[1][i - 1], dp[1][i - 2]);
		dp[1][i] = a[1][i] + max(dp[0][i - 1], dp[0][i - 2]);
	}
	cout << max(dp[0][n - 1], dp[1][n - 1]);
}

对于第一列的球员，总身高就是自己；

对于第二列的球员，一定是选择斜角的那个 (因为 i - 2 不存在)；

之后的所有都可从 i - 1 与 i - 2 中找大的那个；

C - Constanze's Machine

洛谷：CF1245C；

首先，一旦我们在字符串里遇到 m 和 w，直接打印 0 然后 return 0就行了；

其次，所有连续的u或n可组成的方案数目如下：

其中x是连续相同的u或n的长度，y是方案的数量；

相信大家能看出来，看不出也没关系，反正对于 x > 2 ，y (x) = y (x - 1) + y (x - 2)；

一个dp存一下就行；

然后结果就是所有段的方案数量相乘；

#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
long long res = 1, cnt = 0, dp[(int)1e5 + 10], c = 2;
string s;
int main(){
	cin >> s;
	dp[0] = 0;
	dp[1] = 1;
	dp[2] = 2;
	for(int i = 0; i < s.length(); i ++){
		if(s[i] == 'm' || s[i] == 'w'){
			cout << 0;
			return 0;
		}
		if(s[i] != 'u' && s[i] != 'n'){
			if(cnt > 1) res = (res * dp[cnt]) % p;
			cnt = 0;
		}
        else if(s[i] != 0){
			if(s[i] != s[i - 1]){
				if(cnt > 1) res = (res * dp[cnt]) % p;
				cnt = 1;
			}
            else{
				cnt ++;
				if(cnt > c){
					c ++;
					dp[c] = (dp[c - 1] % p + dp[c - 2] % p) % p;
				}
			}
		}else cnt = 1;
	}
	if(cnt > 1) res = (res * dp[cnt]) % p;
	cout << res;
}

要记得 %p 哦；

D - The Number of Products

洛谷：CF1215B；

首先，正子串数量与负子串数量相加一定等于所有子串数量；

而所有子串的数量为 n * (n + 1) / 2，也就是等差数列运算公式；

所以我们就只需要计算一种即可；

#include <bits/stdc++.h>
using namespace std;
int n, a, t = 1, x = 1;
long long res;
int main(){
	cin >> n;
	for(int i = 1; i <= n; i ++){
		scanf("%d", &a);
		x *= (a / abs(a));
		res += (x > 0 ? i - t ++ : t);
	}cout << res << ' ' << (long long) n * (n + 1) / 2 - res;
}

t 计算的是与之前相乘为正的情况；

res数的是负数子串的数量；

每一次负号都会导致之前为正的子串变成负的；

所以只需要res加上之前的正子串即可，反之则加上之前的正子串；

E - Bouncing Ball

洛谷：

CF1415C；

dp，反向计算0的数量，那要是走这条路的代价就是 下标减p 乘以y 加上 0的数量 乘以x；

找到最小值；

#include <bits/stdc++.h>
using namespace std;
int T, b[100010];
string a;
int main()
{
	cin >> T;
	while(T --)
	{
		int res = 1e9, n, p, k, x, y;
		cin >> n >> p >> k >> a;
		p --;
		for(int i = 0; i < n; i ++) b[i] = 0;	
		for(int i = n - 1; i >= p; i --)
		{
			if(i + k >= n) b[i] = (a[i] == '0' ? 1 : 0);
			else b[i] = b[i + k] + (a[i] == '0' ? 1 : 0);
		}
		cin >> x >> y;
		for(int i = p; i < n; i ++)
			res = min(res, (i - p) * y + b[i] * x);
		cout << res << endl;
	}
}

写得好累，思路想挺快的，但是翻译成程序捋了半天。