2020年CSP-J第二轮比赛分析
优秀的拆分（power）
【题目描述】
一般来说，一个正整数可以拆分成若干个正整数的和。例如，1 = 1，10 = 1 + 2 + 3 + 4 等。
对于正整数 𝑛 的一种特定拆分，我们称它为“优秀的”，当且仅当在这种拆分下，𝑛 被分解为了若干个不同的 2 的正整数次幂。注意，一个数 𝑥 能被表示成 2 的正整数次幂，当且仅当 𝑥 能通过正整数个 2 相乘在一起得到。
例如，10 = 8 + 2 = 23 + 21 是一个优秀的拆分。但是，7 = 4 + 2 + 1 =22 + 21 + 20 就不是一个优秀的拆分，因为 1 不是 2 的正整数次幂。
现在，给定正整数 𝑛，你需要判断这个数的所有拆分中，是否存在优秀的拆分。若存在，请你给出具体的拆分方案。
【输入格式】
输入文件名为 power.in。
输入文件只有一行，一个正整数 𝑛，代表需要判断的数。
【输出格式】
输出文件名为 power.out。
如果这个数的所有拆分中，存在优秀的拆分。那么，你需要从大到小输出 这个拆分中的每一个数，相邻两个数之间用一个空格隔开。可以证明，在规定 了拆分数字的顺序后，该拆分方案是唯一的。
若不存在优秀的拆分，输出“-1”（不包含双引号）。
【样例 1输入】
6
【样例 1输出】
4 2
【样例 1 解释】
6 = 4 + 2 = 22 + 21 是一个优秀的拆分。注意，6 = 2 + 2 + 2 不是一个优秀的拆分，因为拆分成的 3 个数不满足每个数互不相同。
【样例 2 输入】
7
【样例 2 输出】
-1
【数据范围与提示】
对于 20% 的数据，𝑛 ≤ 10。
对于另外 20% 的数据，保证 𝑛 为奇数。
对于另外 20% 的数据，保证 𝑛 为 2 的正整数次幂。
对于 80% 的数据，𝑛 ≤ 1024。
对于 100% 的数据，1 ≤ 𝑛 ≤ 1 × 107。
分析
这道题拿了100分，但算法不够好，从小往大找2n，再从大到小输出，应该从大往小找2n,找到一个就输出。
代码
从小到大找
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
long long ans[50];
bool a[50];
int main()
{
freopen("power.in","r",stdin);
freopen("power.out","w",stdout);
memset(a,false,sizeof(a));
long long n,len,i;
scanf("%lld",&n);
if (n&1)
{
printf("-1");
fclose(stdin);
fclose(stdout);
return 0;
}
ans[0]=1;
for(i=1;i<=30;i++)
ans[i]=ans[i-1]*2;
for(i=0;n>0;i++,n/=2)
a[i]=n&1;
for(i--;i>=1;i--)
if (a[i])
printf("%lld ",ans[i]);
fclose(stdin);
fclose(stdout);
return 0;
}
直播获奖（live）
【题目描述】
NOI2130 即将举行。为了增加观赏性，CCF 决定逐一评出每个选手的成绩，并直播即时的获奖分数线。本次竞赛的获奖率为 𝑤%，即当前排名前 𝑤% 的选手的最低成绩就是即时的分数线。
更具体地，若当前已评出了 𝑝个选手的成绩，则当前计划获奖人数为max(1, ⌊𝑝 × 𝑤%⌋)，其中 𝑤是获奖百分比，⌊𝑥⌋ 表示对 𝑥向下取整，max(𝑥, 𝑦) 表示 𝑥和 𝑦中较大的数。如有选手成绩相同，则所有成绩并列的选手都能获奖，因此实际获奖人数可能比计划中多。
作为评测组的技术人员，请你帮CCF 写一个直播程序。
【输入格式】
输入文件名为 live.in。
第 1 行两个正整数 𝑛, 𝑤。分别代表选手总数与获奖率。
第 2 行有 𝑛 个非负整数，依次代表逐一评出的选手成绩。
【输出格式】
输出文件名为 live.out。
只有一行，包含 𝑛 个非负整数，依次代表选手成绩逐一评出后，即时的获奖分数线。相邻两个整数间用一个空格分隔。
【样例 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
【数据范围与提示】
对于所有测试点，每个选手的成绩均为不超过 600 的非负整数，获奖百分比 𝑤 是一个正整数且 1 ≤ 𝑤 ≤ 99。
在计算计划获奖人数时，如用浮点类型的变量（如 C/C++中的float、double，Pascal 中的 real、double、extended 等）存储获奖比例 𝑤%，则计算 5 × 60% 时的结果可能为 3.000001，也可能为 2.999999，向下取整后的结果不确定。因此，建议仅使用整型变量，以计算出准确值。
分析
这道题应该用计数排序，毎加入一个数就加入数组，再算出获奖比例，循环找到答案，输出。考试时用了二分插入排序，还写错了，只得了20分
错误代码
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
using namespace std;
int a[100010];
//find(a,a+i,max(1,(i+1)*w/100))
int finds(int l,int r,int k)
{
int mid;
while(l<r)
{
mid=(l+r)/2;
if (a[mid]>k)
l=mid+1;
else
r=mid;
}
return r;
}
int main()
{
freopen("live.in","r",stdin);
freopen("live.out","w",stdout);
int n,w,i,j,p,answ,t;
scanf("%d%d%d",&n,&w,&a[1]);
printf("%d ",a[1]);
for(i=2;i<=n;i++)
{
scanf("%d",&a[i]);
answ=finds(1,i-1,a[i]);
t=a[i];
for(j=i;j>answ;j--)
a[j]=a[j-1];
a[answ]=t;
printf("%d ",a[max(1,i*w/100)]);
}
fclose(stdin);
fclose(stdout);
return 0;
}
表达式（expr）
【题目描述】
小C 热衷于学习数理逻辑。有一天，他发现了一种特别的逻辑表达式。在这种逻辑表达式中，所有操作数都是变量，且它们的取值只能为 0 或 1，运算从左往右进行。如果表达式中有括号，则先计算括号内的子表达式的值。特别的，这种表达式有且仅有以下几种运算：
与运算：𝑎&𝑏。当且仅当 𝑎和 𝑏的值都为 1时，该表达式的值为1。其余情况该表达式的值为 0。
或运算：𝑎|𝑏。当且仅当 𝑎和 𝑏的值都为 0时，该表达式的值为0。其余情况该表达式的值为 1。
取反运算：! 𝑎。当且仅当 𝑎的值为 0时，该表达式的值为 1。其余情况该表达式的值为 0。
小C想知道，给定一个逻辑表达式和其中每一个操作数的初始取值后，再取反某一个操作数的值时，原表达式的值为多少。
为了化简对表达式的处理，我们有如下约定：
表达式将采用后缀表达式的方式输入。后缀表达式的定义如下：
如果 𝐸是一个操作数，则 𝐸的后缀表达式是它本身。
如果 𝐸是 𝐸1 𝑜𝑝 E2 形式的表达式，其中 𝑜𝑝 是任何二元操作符，且优先级不高于 𝐸1、E2 中括号外的操作符，则 𝐸 的后缀式为 𝐸1′ E2′𝑜𝑝，其中𝐸1′ E2′分别为𝐸1、E2 的后缀式。
如果 𝐸是 (𝐸1) 形式的表达式，则 𝐸1 的后缀式就是 𝐸的后缀式。同时为了方便，输入中：
与运算符（&）、或运算符（|）、取反运算符（！）的左右均有一个空格，但表达式末尾没有空格。
操作数由小写字母 x与一个正整数拼接而成，正整数表示这个变量的下标。例如：x10，表示下标为 10的变量 𝑥10。数据保证每个变量在表达式中出现恰好一次。
【输入格式】
输入文件名为 expr.in。
第一行包含一个字符串 𝑠，表示上文描述的表达式。
第二行包含一个正整数 𝑛，表示表达式中变量的数量。表达式中变量的下标为 1,2, … , 𝑛。
第三行包含 𝑛 个整数，第 𝑖 个整数表示变量 𝑥𝑖 的初值。第四行包含一个正整数 𝑞，表示询问的个数。
接下来 𝑞 行，每行一个正整数，表示需要取反的变量的下标。注意，每一个询问的修改都是临时的，即之前询问中的修改不会对后续的询问造成影响。
数据保证输入的表达式合法。变量的初值为 0 或 1。
【输出格式】
输出文件名为 expr.out。
输出一共有 𝑞 行，每行一个 0 或 1，表示该询问下表达式的值。
【样例 1 输入】
x1 x2 & x3 |
3
1 0 1
3
1
2
3
【样例 1输出】
1
1
0
【样例 1解释】
该后缀表达式的中缀表达式形式为 (𝑥1 & 𝑥2 ) | 𝑥3 。
对于第一次询问，将 𝑥1 的值取反。此时，三个操作数对应的赋值依次为0，0，1。原表达式的值为 (0 & 0) | 1 = 1。
对于第二次询问，将 𝑥2 的值取反。此时，三个操作数对应的赋值依次为1，1，1。原表达式的值为 (1 & 1) | 1 = 1。
对于第三次询问，将 𝑥3 的值取反。此时，三个操作数对应的赋值依次为1，0，0。原表达式的值为 (1 & 0) | 0 = 0。
【样例 2 输入】
x1 ! x2 x4 | x3 x5 ! & & ! &
5
0 1 0 1 1
3
1
3
5
【样例 2 输出】
0
1
1
【样例 2 解释】
该表达式的中缀表达式形式为 ( ! 𝑥1 ) & (! (( 𝑥2 | 𝑥4 ) & ( 𝑥3 & (! 𝑥5 ) ) ))。
【数据范围与提示】
对于 20% 的数据，表达式中有且仅有与运算（&）或者或运算（|）。
对于另外 30% 的数据，|𝑠| ≤ 1000，𝑞 ≤ 1000，𝑛 ≤ 1000。
对于另外 20% 的数据，变量的初值全为 0 或全为 1。
对于 100% 的数据，1 ≤ |𝑠| ≤ 1 × 106，1 ≤ 𝑞 ≤ 1 × 105，2 ≤ 𝑛 ≤ 1 × 105。
其中，|𝑠| 表示字符串 𝑠 的长度。
分析
这道题我的算法是：先将数值代入，计算出取反，保存每个变量的位置。每输入一个变量名，将该位置的数取反，再计算出结果。正确算法是建一棵树，改变变量后，一边计算一边将结果向根传。
错误代码
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
using namespace std;
string str,js,t1;
int a[100010],w[100010];
void read()
{
char c;
str="";
for(c=getchar();c!='\n';c=getchar())
str+=c;
return;
}
int main()
{
freopen("expr.in","r",stdin);
freopen("expr.out","w",stdout);
int i,len,n,t,s,q,x,j,jslen;
read();
len=str.size();
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
scanf("%d",&q);
for(i=0;i<len;i++)
{
if (str[i]==' ')
{
str.erase(i,1);
i--;
len--;
}
else
{
if (str[i]=='x')
{
for(t=i,s=0,i++;str[i]!=' ';i++)
s=s*10+str[i]-'0';
str.erase(t,i-t+1);
t1=char(a[s]);
str.insert(t,t1);
len-=i-t;
w[s]=t;
i=t;
}
else
if (str[i]=='!')
{
str.erase(i,1);
str[i-1]=char(!(bool(str[i-1])));
i--;
len--;
}
}
}
for(i=0;i<q;i++)
{
scanf("%d",&x);
js=str;
jslen=len;
js[w[x]]=char(!(bool(js[w[x]])));
for(j=0;j<jslen;j++)
{
if (js[j]=='|')
{
t1=char(bool(js[j-2])|bool(js[j-1]));
js.erase(j-2,3);
js.insert(j-2,t1);
jslen-=2;
j-=2;
}
else
if (js[j]=='&')
{
t1=char(bool(js[j-2])&bool(js[j-1]));
js.erase(j-2,3);
js.insert(j-2,t1);
jslen-=2;
j-=2;
}
}
printf("%d\n",int(js[0]));
}
fclose(stdin);
fclose(stdout);
return 0;
}
方格取数（number）
【题目描述】
设有 𝑛 × 𝑚的方格图，每个方格中都有一个整数。现有一只小熊，想从图的左上角走到右下角，每一步只能向上、向下或向右走一格，并且不能重复经过已经走过的方格，也不能走出边界。小熊会取走所有经过的方格中的整数，求它能取到的整数之和的最大值。
【输入格式】
输入文件名为 number.in。
第 1 行两个正整数 𝑛, 𝑚。
接下来 𝑛 行每行 𝑚 个整数，依次代表每个方格中的整数。
【输出格式】
输入文件名为 number.out。
一个整数，表示小熊能取到的整数之和的最大值。
【样例 1 输入】
3 4
1 -1 3 2
2 -1 4 -1
-2 2 -3 -1
【样例 1输出】
9
【样例 1解释】
取到的数之和为 1 + 2 + (-1) + 4 + 3 + 2 + (-1) + (-1) = 9，可以证明为最大值。
【样例 2 输入】
2 5
-1 -1 -3 -2-7
-2 -1 -4 -1-2
【样例 2 输出】
-10
【样例 2 解释】
取到的数之和为(-1) + (-1) + (-3) + (-2) + (-1) + (-2) = -10，可以证明为最大值。因此，请注意，取到的数之和的最大值也可能是负数。
【数据范围与提示】
对于20%的数据，𝑛,𝑚 ≤ 5。
对于40%的数据，𝑛,𝑚 ≤ 50。
对于70%的数据，𝑛,𝑚 ≤ 300。
对于100% 的数据，1 ≤ 𝑛, 𝑚 ≤ 1000。方格中整数的绝对值不超过 104。
分析
这道题是动态规划，考试时没有想到可以上下扫2次，打了暴力，得了25分。应该先把每一行算出来，再从左到右每一列扫2次。动态转移方程：f[i][j]=f[i][j-1]+a[i][j],f[i][j]=max(f[i][j],f[i-1][j]+a[i][j]),f[i][j]=max(f[i][j],f[i+1][j]+a[i][j])。
错误代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
int n,m,a[1010][1010];
bool b[1010][1010];
long long ans=-10000000000;
void dfs(int x,int y,long long sum)
{
if (x==n&&y==m)
{
ans=max(ans,sum);
return;
}
if (1<=x&&x<=n&&1<=y&&y<=m&&b[x][y])
{
b[x][y]=0;
dfs(x-1,y,sum+a[x][y]);
dfs(x,y+1,sum+a[x][y]);
dfs(x+1,y,sum+a[x][y]);
b[x][y]=1;
}
return;
}
int main()
{
freopen("number.in","r",stdin);
freopen("number.out","w",stdout);
int i,j;
memset(b,true,sizeof(b));
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
scanf("%d",&a[i][j]);
dfs(1,1,a[n][m]);
printf("%lld",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
1911
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
