[题解] CSP-J 2020题解

CSP-J 2020题解

本次考试还是很有用的，至少把我浇了一盆冷水。
当使用民间数据自测的时候，我就自闭了。
估分是320，但有些比较低级的错误直接少掉80。
而且这套题应该上350才正常吧，也不是像平时训练一样难。
主要是平时的时候太依赖于评测机了，小错误就都没注意，我认为在平时训练当中就应该一次成型，因为考试只有一次提交机会。
基础概念也需要搞清楚，比如运算优先级等等。
心态也要调整好。就这次考试而言，我的心态是极差的。多在考试之前鼓励下自己。可能就会好些吧！
调整心态，继续努力，把自己当做起跑线上的人，路还很长，我们还会继续！！

不多说了，上题解

T1 优秀的拆分

题目描述

一般来说，一个正整数可以拆分成若干个正整数的和。

例如，(1=1)，(10=1+2+3+4) 等。对于正整数(n)的一种特定拆分，我们称它为“优秀的”，当且仅当在这种拆分下，(n)被分解为了若干个不同的(2)的正整数次幂。注意，一个数(x)能被表示成(2)的正整数次幂，当且仅当(x)能通过正整数个(2)相乘在一起得到。

例如，(10=8+2=2^3+2^1)是一个优秀的拆分。但是，(7=4+2+1=2^2+2^1+2^0)就不是一个优秀的拆分，因为(1)不是(2)的正整数次幂。

现在，给定正整数(n)，你需要判断这个数的所有拆分中，是否存在优秀的拆分。若存在，请你给出具体的拆分方案。

输入格式

输入只有一行，一个整数(n)，代表需要判断的数。

输出格式

如果这个数的所有拆分中，存在优秀的拆分。那么，你需要从大到小输出这个拆分中的每一个数，相邻两个数之间用一个空格隔开。可以证明，在规定了拆分数字的顺序后，该拆分方案是唯一的。

若不存在优秀的拆分，输出 -1。

输入输出样例

输入 #1

6

输出 #1

4 2

输入 #2

7

输出 #2

-1

说明/提示
样例 1 解释
(6=4+2=2^2+2^1)是一个优秀的拆分。注意，(6=2+2+2)不是一个优秀的拆分，因为拆分成的(3)个数不满足每个数互不相同。

数据规模与约定

对于(20\%)的数据，(n le 10)。
对于另外(20\%)的数据，保证(n)为奇数。
对于另外(20%)的数据，保证(n)为(2)的正整数次幂。
对于(80\%)的数据，(n le 1024)。
对于(100\%)的数据，(1 le n le 1 imes 10^7)。

思路

简单，倒着枚举二的正整数次幂即可。

C++代码

#include <queue>
#include <cstdio>
using namespace std;
queue<int> q;
int n;
int main() {
	scanf("%d", &n);
	for(int i = 30; i >= 1; i--) {
		int now = (1 << i);
		if(now <= n) {
			n -= now;
			q.push(now);
		}
	}
	if(n != 0)
		printf("-1");
	else
		while(!q.empty()) {
			printf("%d ", q.front());
			q.pop(); 
		}
	return 0;
}

T2 直播获奖

题目描述

NOI2130 即将举行。为了增加观赏性，CCF 决定逐一评出每个选手的成绩，并直播即时的获奖分数线。本次竞赛的获奖率为(w\%)，即当前排名前(w\%)的选手的最低成绩就是即时的分数线。

更具体地，若当前已评出了(p)个选手的成绩，则当前计划获奖人数为(max(1, lfloor p * w \% floor))，其中(w)是获奖百分比，(lfloor x floor)表示对(x)向下取整，(max(x,y))表示(x)和(y)中较大的数。如有选手成绩相同，则所有成绩并列的选手都能获奖，因此实际获奖人数可能比计划中多。

作为评测组的技术人员，请你帮 CCF 写一个直播程序。

输入格式

第一行有两个整数(n, w)。分别代表选手总数与获奖率。
第二行有(n)个整数，依次代表逐一评出的选手成绩。

输出格式

只有一行，包含(n)个非负整数，依次代表选手成绩逐一评出后，即时的获奖分数线。相邻两个整数间用一个空格分隔。

输入输出样例

输入 #1

10 60
200 300 400 500 600 600 0 300 200 100

输出 #1

200 300 400 400 400 500 400 400 300 300

输入 #2

10 30
100 100 600 100 100 100 100 100 100 100

输出 #2

100 100 600 600 600 600 100 100 100 100

说明/提示
样例 1 解释

数据规模与约定

对于所有测试点，每个选手的成绩均为不超过(600)的非负整数，获奖百分比(w)是一个正整数且(1 le w le 99)。

提示
在计算计划获奖人数时，如用浮点类型的变量（如 C/C++ 中的 float 、 double，Pascal 中的 real 、 double 、 extended 等）存储获奖比例 w%w%，则计算(5 imes 60\%)时的结果可能为(3.000001)，也可能为(2.999999)，向下取整后的结果不确定。因此，建议仅使用整型变量，以计算出准确值。

思路

使用一个大根堆与一个小根堆来模拟。
大根堆来储存分数线以下的分数。
小根堆来储存分数线以上的分数。
模拟分数线的波动即可。

C++代码

#include <queue>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 1e5 + 5;
priority_queue<int, vector<int>, greater<int> > q1;
priority_queue<int> q2;
int a[MAXN];
int n, w;
int main() {
	scanf("%d %d", &n, &w);
	for(int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
	}
	int id = 1;
	q1.push(a[1]);
	printf("%d ", a[1]);
	for(int i = 2; i <= n; i++) {
		int now = i * w / 100;
		if(a[i] > q1.top()) {
			q1.push(a[i]);
			int k = q1.top();
			q2.push(k);
			q1.pop();
		}
		else {
			q2.push(a[i]);
		}
		if(now > id) {
			id = now;
			int k = q2.top(); q2.pop();
			q1.push(k);
		}
		printf("%d ", q1.top());
	}
	return 0;
}

T3 表达式

题目描述

小 C 热衷于学习数理逻辑。有一天，他发现了一种特别的逻辑表达式。在这种逻辑表达式中，所有操作数都是变量，且它们的取值只能为(0)或 (1)，运算从左往右进行。如果表达式中有括号，则先计算括号内的子表达式的值。特别的，这种表达式有且仅有以下几种运算：

1. 与运算：a & b。当且仅当(a)和(b)的值都为(1)时，该表达式的值为(1)。其余情况该表达式的值为(0)。
2. 或运算：a | b。当且仅当(a)和(b)的值都为(0)时，该表达式的值为(0)。其余情况该表达式的值为(1)。
3. 取反运算：!a。当且仅当(a)的值为(0)时，该表达式的值为(1)。其余情况该表达式的值为(0)。

小 C 想知道，给定一个逻辑表达式和其中每一个操作数的初始取值后，再取反某一个操作数的值时，原表达式的值为多少。

为了化简对表达式的处理，我们有如下约定：

表达式将采用后缀表达式的方式输入。

后缀表达式的定义如下：

1. 如果(E)是一个操作数，则(E)的后缀表达式是它本身。
2. 如果(E)是(E_1~ exttt{op}~E)形式的表达式，其中( exttt{op})是任何二元操作符，且优先级不高于(E_1)、(E_2)中括号外的操作符，则(E)的后缀式为 (E_1' E_2' exttt{op})，其中(E_1')、(E_2')分别为(E_1)、(E_2)的后缀式。
3. 如果(E)是(E_1)形式的表达式，则(E_1)的后缀式就是(E)的后缀式。
   同时为了方便，输入中：

与运算符（&）、或运算符（|）、取反运算符（！）的左右均有一个空格，但表达式末尾没有空格。
操作数由小写字母(x)与一个正整数拼接而成，正整数表示这个变量的下标。例如：x10，表示下标为(10)的变量(x_{10})。数据保证每个变量在表达式中出现恰好一次。

输入格式

第一行包含一个字符串(s)，表示上文描述的表达式。
第二行包含一个正整数(n)，表示表达式中变量的数量。表达式中变量的下标为(1,2, cdots , n)。
第三行包含(n)个整数，第(i)个整数表示变量(x_i)的初值。
第四行包含一个正整数(q)，表示询问的个数。
接下来(q)行，每行一个正整数，表示需要取反的变量的下标。注意，每一个询问的修改都是临时的，即之前询问中的修改不会对后续的询问造成影响。
数据保证输入的表达式合法。变量的初值为(0)或(1)。

输出格式

输出一共有(q)行，每行一个(0)或(1)，表示该询问下表达式的值。

输入输出样例

输入 #1

x1 x2 & x3 |
3
1 0 1
3
1
2
3

输出 #1

1
1
0

输入 #2

x1 ! x2 x4 | x3 x5 ! & & ! &
5
0 1 0 1 1
3
1
3
5

输出 #2

0
1
1

说明/提示
样例 1 解释
该后缀表达式的中缀表达式形式为((x_1 & x_2) | x_3)。

对于第一次询问，将(x_1)的值取反。此时，三个操作数对应的赋值依次为(0)，(0)，(1)。原表达式的值为((0&0)|1=1)。
对于第二次询问，将(x_2)的值取反。此时，三个操作数对应的赋值依次为(1)，(1)，(1)。原表达式的值为((1&1)|1=1)。
对于第三次询问，将(x_3)的值取反。此时，三个操作数对应的赋值依次为(1)，(0)，(0)。原表达式的值为((1&0)|0=0)。
样例 2 解释
该表达式的中缀表达式形式为((!x_1)&(!((x_2|x_4)&(x_3&(!x_5)))))。

数据规模与约定

对于(20\%)的数据，表达式中有且仅有与运算（&）或者或运算（|）。
对于另外(30\%)的数据，(|s| le 1000)，(q le 1000)，(n le 1000)。
对于另外(20\%)的数据，变量的初值全为(0)或全为(1)。
对于(100\%)的数据，(1 le |s| le 1 imes 10^6)，(1 le q le 1 imes 10^5)，(2 le n le 1 imes 10^5)。
其中，(|s|)表示字符串(s)的长度。

思路

首先对于仅有或运算和且运算的情况，不难想到可以骗分，再利用后缀表达式跑一遍暴力就可以骗到50分，时间复杂度为(O(nq))。
这种做法可以优化吗？或运算和且运算都有两个数字进行运算，是不是很像一颗二叉树。而且这颗二叉树有一个特性：每个父节点都必有两个子节点。利用这一点，可以去看若改变这颗树上的某一个值，会不会对本次计算产生影响，进而推出是否会对整个结果产生影响，预处理一次时间复杂度为(O(n))，即便利这整棵树。总的来看加上后面的查询，时间复杂度为(O(n+q))。

C++代码

#include <stack>
#include <cstdio>
#include <string>
#include <iostream>
using namespace std;
void Quick_Read(int &Number) {
	Number = 0;
	char c = getchar();
	int op = 1;
	while (c < '0' || c > '9') {
		if (c == '-')
			op = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') {
		Number = (Number << 1) + (Number << 3) + c - 48;
		c = getchar();
	}
	Number *= op;
}
const int MAXN = 1e6 + 5;
struct Node {
	int Left_Child, Right_Child;
	int Value, Index, Operator;
};
stack<int> s;
string c;
Node Tree[MAXN];
bool Alter[MAXN];
int Num[MAXN];
int len, n, q;
void calc(int x) {
	if(Tree[x].Operator == -1) {
		Alter[Tree[x].Index] = 1;
		return;
	}
	if(!Tree[x].Operator)
		calc(Tree[x].Left_Child);
	else if(Tree[x].Operator == 1) {
		int Left_Child = Tree[x].Left_Child;
		int Right_Child = Tree[x].Right_Child;
		if(Tree[Left_Child].Value + Tree[Right_Child].Value == 2) {
			calc(Left_Child);
			calc(Right_Child);
		}
		else if(Tree[Left_Child].Value)
			calc(Right_Child);
		else if(Tree[Right_Child].Value)
			calc(Left_Child);
	}
	else {
		int Left_Child = Tree[x].Left_Child;
		int Right_Child = Tree[x].Right_Child;
		if(Tree[Left_Child].Value + Tree[Right_Child].Value == 0) {
			calc(Left_Child);
			calc(Right_Child);
		}
		else if(!Tree[Left_Child].Value)
			calc(Right_Child);
		else if(!Tree[Right_Child].Value)
			calc(Left_Child);
	}
}
void Read() {
	int A;
	getline(cin, c);
	Quick_Read(n);
	for(int i = 1; i <= n; i++)
		Quick_Read(Num[i]);
	for(int i = 0; i < c.length(); i++) {
		if(c[i] == 'x') {
			int x = 0;
			while(c[i + 1] <= '9' && c[i + 1] >= '0') {
				x = x * 10 + c[i + 1] - 48;
				i++;
			}
			len++;
			Tree[len].Value = Num[x];
			Tree[len].Index = x;
			Tree[len].Operator = -1;
			s.push(len);
			continue;
		}
		if(c[i] == '!') {
			len++;
			Tree[len].Value = !Tree[s.top()].Value;
			Tree[len].Left_Child = s.top(); s.pop();
			Tree[len].Operator = 0;
			s.push(len);
			continue;
		}
		if(c[i] == '&') {
			len++;
			int Number1 = s.top(); s.pop();
			int Number2 = s.top(); s.pop();
			Tree[len].Value = Tree[Number1].Value & Tree[Number2].Value;
			Tree[len].Operator = 1;
			Tree[len].Left_Child = Number1;
			Tree[len].Right_Child = Number2;
			s.push(len);
			continue;
		}
		if(c[i] == '|') {
			len++;
			int Number1 = s.top(); s.pop();
			int Number2 = s.top(); s.pop();
			Tree[len].Value = Tree[Number1].Value | Tree[Number2].Value;
			Tree[len].Operator = 2;
			Tree[len].Left_Child = Number1;
			Tree[len].Right_Child = Number2;
			s.push(len);
			continue;
		}
	}
}
void Write() {
	int A;
	Quick_Read(q);
	for(int i = 1; i <= q; i++) {
		Quick_Read(A);
		if(Alter[A])
			printf("%d
", !Tree[len].Value);
		else
			printf("%d
", Tree[len].Value);
	}
}
int main() {
	Read(); 
	calc(len);
	Write();
	return 0;
}

T4 方格取数

题目描述

设有(n imes m)的方格图，每个方格中都有一个整数。现有一只小熊，想从图的左上角走到右下角，每一步只能向上、向下或向右走一格，并且不能重复经过已经走过的方格，也不能走出边界。小熊会取走所有经过的方格中的整数，求它能取到的整数之和的最大值。

输入格式

第一行有两个整数(n, m)。

接下来(n)行每行(m)个整数，依次代表每个方格中的整数。

输出格式

一个整数，表示小熊能取到的整数之和的最大值。

输入输出样例

输入 #1

3 4
1 -1 3 2
2 -1 4 -1
-2 2 -3 -1

输出 #1

9

输入 #2

2 5
-1 -1 -3 -2 -7
-2 -1 -4 -1 -2

输出 #2

-10

说明/提示

按上述走法，取到的数之和为(1 + 2 + (-1) + 4 + 3 + 2 + (-1) + (-1) = 9)，可以证明为最大值。

注意，上述走法是错误的，因为第(2)行第(2)列的方格走过了两次，而根据题意，不能重复经过已经走过的方格。

另外，上述走法也是错误的，因为没有走到右下角的终点。
数据规模与约定
对于(20\%)的数据，(n, m le 5)。
对于(40\%)的数据，(n, m le 50)。
对于(70\%)的数据，(n, m le 300)。
对于(100\%)的数据，(1 le n,m le 10^3)。方格中整数的绝对值不超过(10^4)。

思路

看到这道题的时候想到的是用最短路。
但是仔细想想，若用Dijkstra有正边有负边，不可以用。若用SPFA，回有环。若强行用分层图来维护的话，时间复杂度就为(O(n^2mlog(n^2m)))，肯定会超时。
于是在考场上就想了一个70分的dp带前缀和优化，时间复杂度为(O(n^2m)) 。
代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 1e3 + 5;
int dp[MAXN][MAXN];
int dist[MAXN];
int a[MAXN][MAXN];
int n, m;
int main() {
	scanf("%d %d", &n, &m);
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++)
			scanf("%d", &a[i][j]);
	for(int i = 1; i <= n; i++) {
		for(int j = 1; j <= i; j++)
			dp[1][i] += a[j][1];
	}
	for(int i = 2; i <= m; i++) {
		dist[1] = a[1][i];
		for(int j = 2; j <= n; j++)
			dist[j] = dist[j - 1] + a[j][i];
		for(int j = 1; j <= n; j++)
			dp[i][j] = dp[i - 1][j] + a[j][i];
		for(int j = 1; j <= n; j++) {
			for(int k = 1; k <= n; k++) {
				dp[i][j] = max(dp[i][j], dp[i - 1][k] + dist[max(j, k)] - dist[min(j, k) - 1]);
			}
		}
	}
	printf("%d", dp[m][n]);
	return 0;
}

（顺便说一句，考试时宏定义Max和Min没加括号，直接导致这题爆零，正确的宏定义应为：#define Min(a, b) ((a) < (b) ? (a) : (b))。）
如何来优化呢？
定义两个dp，一个记录从上往下走的答案，一个记录从下往上走的答案。
状态转移方程：

1. 只可以向右走，而不能向左走，就是上一层的路径转换到本层即可
   (f[i][j][1]=f[i][j][0]=max(f[i-1][j][1],f[i-1][j][0])+a[i][j])
2. 向下走
   (f[i][j][1]=max(f[i][j][1],f[i][j−1][1]+a[i][j]))
3. 向下走
   (f[i][j][0]=max(f[i][j][0],f[i][j+1][0]+a[i][j]))

C++代码

#include <cstdio>
#define LL long long
#define INF 1e17
#define Max(a, b) ((a) > (b) ? (a) : (b))
void Quick_Read(LL &Number) {
	Number = 0;
	char c = getchar();
	LL op = 1;
	while (c < '0' || c > '9') {
		if (c == '-')
			op = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') {
		Number = (Number << 1) + (Number << 3) + c - 48;
		c = getchar();
	}
	Number *= op;
}
const LL MAXN = 1e3 + 5;
LL Map[MAXN][MAXN], dp[MAXN][MAXN][2];
LL n, m;
int main() {
	Quick_Read(n);
	Quick_Read(m);
	for(int i = 1; i <= n; i++) {
		for(int j = 1; j <= m; j++) {
			Quick_Read(Map[i][j]);
			dp[i][j][0] = dp[i][j][1] = -INF;
		}
	}
	dp[1][1][0] = dp[1][1][1] = Map[1][1];
	for(int i = 2; i <= n; i++)
		dp[i][1][1] = dp[i - 1][1][1] + Map[i][1];
	for(int j = 2; j <= m; j++) {
		dp[1][j][1] = dp[1][j][0] = Max(dp[1][j - 1][0], dp[1][j - 1][1]) + Map[1][j];
		for(int i = 2; i <= n; i++) {
			dp[i][j][0] = Max(dp[i][j - 1][0], dp[i][j - 1][1]) + Map[i][j];
			dp[i][j][1] = Max(dp[i][j][0], dp[i - 1][j][1] + Map[i][j]);
		}
		for(int i = n - 1; i > 0; i--)
			dp[i][j][0] = Max(dp[i][j][0], dp[i + 1][j][0] + Map[i][j]);
	}
	printf("%lld", Max(dp[n][m][0], dp[n][m][1]));
	return 0;
}