CSP-J第二轮试题-2022年-3题-阿里云开发者社区

参考：

前缀、中缀和后缀表达式详解，中缀表达式到后缀表达式的转换规则，以及后缀表达式的计算规则，附计算代码

22张图带你深入剖析前缀、中缀、后缀表达式以及表达式求值

总结

本系列为CSP-J/S算法竞赛真题讲解，会按照年份分析每年的真题，并给出对应的答案。本文为2022年真题。

https://www.luogu.com.cn/problem/list?tag=343&page=1

[CSP-J 2022] 逻辑表达式

题目描述

逻辑表达式是计算机科学中的重要概念和工具，包含逻辑值、逻辑运算、逻辑运算优先级等内容。

在一个逻辑表达式中，元素的值只有两种可能：0 00（表示假）和 1 11（表示真）。元素之间有多种可能的逻辑运算，本题中只需考虑如下两种：“与”（符号为 &）和“或”（符号为 |）。其运算规则如下：

0 & 0 = 0 & 1 = 1 & 0 = 0 0 \mathbin{\&} 0 = 0 \mathbin{\&} 1 = 1 \mathbin{\&} 0 = 00&0=0&1=1&0=0，1 & 1 = 1 1 \mathbin{\&} 1 = 11&1=1；

0 ∣ 0 = 0 0 \mathbin{|} 0 = 00∣0=0，0 ∣ 1 = 1 ∣ 0 = 1 ∣ 1 = 1 0 \mathbin{|} 1 = 1 \mathbin{|} 0 = 1 \mathbin{|} 1 = 10∣1=1∣0=1∣1=1。

在一个逻辑表达式中还可能有括号。规定在运算时，括号内的部分先运算；两种运算并列时，& 运算优先于 | 运算；同种运算并列时，从左向右运算。

比如，表达式 0|1&0 的运算顺序等同于 0|(1&0)；表达式 0&1&0|1 的运算顺序等同于 ((0&1)&0)|1。

此外，在 C++ 等语言的有些编译器中，对逻辑表达式的计算会采用一种“短路”的策略：在形如 a&b 的逻辑表达式中，会先计算 a 部分的值，如果 a = 0 a = 0a=0，那么整个逻辑表达式的值就一定为 0 00，故无需再计算 b 部分的值；同理，在形如 a|b 的逻辑表达式中，会先计算 a 部分的值，如果 a = 1 a = 1a=1，那么整个逻辑表达式的值就一定为 1 11，无需再计算 b 部分的值。

现在给你一个逻辑表达式，你需要计算出它的值，并且统计出在计算过程中，两种类型的“短路”各出现了多少次。需要注意的是，如果某处“短路”包含在更外层被“短路”的部分内则不被统计，如表达式 1|(0&1) 中，尽管 0&1 是一处“短路”，但由于外层的 1|(0&1) 本身就是一处“短路”，无需再计算 0&1 部分的值，因此不应当把这里的 0&1 计入一处“短路”。

输入格式

从文件expr.in中读入数据。

输入共一行，一个非空字符串 s ss 表示待计算的逻辑表达式。

输出格式

输出到文件expr.out中。

输出共两行，第一行输出一个字符 0 或 1，表示这个逻辑表达式的值；第二行输出两个非负整数，分别表示计算上述逻辑表达式的过程中，形如 a&b 和 a|b 的“短路”各出现了多少次。

样例 #1

样例输入 #1

0&(1|0)|(1|1|1&0)

样例输出 #1

1
1 2

样例 #2

样例输入 #2

(0|1&0|1|1|(1|1))&(0&1&(1|0)|0|1|0)&0

样例输出 #2

0
2 3

提示

【样例解释 #1】

该逻辑表达式的计算过程如下，每一行的注释表示上一行计算的过程：

0&(1|0)|(1|1|1&0)
=(0&(1|0))|((1|1)|(1&0)) //用括号标明计算顺序
=0|((1|1)|(1&0))   //先计算最左侧的 &，是一次形如 a&b 的“短路”
=0|(1|(1&0))       //再计算中间的 |，是一次形如 a|b 的“短路”
=0|1               //再计算中间的 |，是一次形如 a|b 的“短路”
=1

【样例 #3】

见附件中的 expr/expr3.in 与 expr/expr3.ans。

【样例 #4】

见附件中的 expr/expr4.in 与 expr/expr4.ans。

【数据范围】

设 ∣ s ∣ \lvert s \rvert∣s∣ 为字符串 s ss 的长度。

对于所有数据，1 ≤ ∣ s ∣ ≤ 10 6 1 \le \lvert s \rvert \le {10}^61≤∣s∣≤106。保证 s ss 中仅含有字符 0、1、&、|、(、) 且是一个符合规范的逻辑表达式。保证输入字符串的开头、中间和结尾均无额外的空格。保证 s ss

中没有重复的括号嵌套（即没有形如 ((a)) 形式的子串，其中 a 是符合规范的逻辑表

达式）。

测试点编号	∣ s ∣ ≤ \lvert s \rvert \le∣s∣≤	特殊条件
1 ∼ 2 1 \sim 21∼2	3 33	无
3 ∼ 4 3 \sim 43∼4	5 55	无
5 55	2000 20002000	1
6 66	2000 20002000	2
7 77	2000 20002000	3
8 ∼ 10 8 \sim 108∼10	2000 20002000	无
11 ∼ 12 11 \sim 1211∼12	10 6 {10}^6106	1
13 ∼ 14 13 \sim 1413∼14	10 6 {10}^6106	2
15 ∼ 17 15 \sim 1715∼17	10 6 {10}^6106	3
18 ∼ 20 18 \sim 2018∼20	10 6 {10}^6106	无

其中：

特殊性质 1 为：保证 s ss 中没有字符 &。

特殊性质 2 为：保证 s ss 中没有字符 |。

特殊性质 3 为：保证 s ss 中没有字符 ( 和 )。

【提示】

以下给出一个“符合规范的逻辑表达式”的形式化定义：

字符串 0 和 1 是符合规范的；
如果字符串 s 是符合规范的，且 s 不是形如 (t) 的字符串（其中 t 是符合规范的），那么字符串 (s) 也是符合规范的；
如果字符串 a 和 b 均是符合规范的，那么字符串 a&b、a|b 均是符合规范的；
所有符合规范的逻辑表达式均可由以上方法生成。

//P8815 [CSP-J 2022] 逻辑表达式
#include <iostream>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
char s[1000010];
struct number {
    int num;
    int op1,op2; //&，|
};
stack<number> n;//数字
stack<char> f;
int l;
void cul() {
    number n2=n.top();//操作数1
    n.pop();
    number n1=n.top();//操作数2
    n.pop();
    char c=f.top();
    f.pop();
    int ans;
    if(c=='&') {
        ans=n1.num&n2.num;
        if(n1.num==0) n.push({ans,n1.op1+1,n1.op2});//通过&操作 ,且短路
        else n.push({ans,n1.op1+n2.op1,n1.op2+n2.op2});
    } else {
        ans=n1.num|n2.num;
        if(n1.num==1) n.push({ans,n1.op1,n1.op2+1});//通过|操作 ,且短路
        else n.push({ans,n1.op1+n2.op1,n1.op2+n2.op2});
    }
    //cout<<"cul"<<n1.num<<c<<n2.num<<'='<<ans<<" "<<n.top().op1<<' '<<n.top().op2<<endl;
    return;
}
void work() {
    for(int i=0; i<l; i++) {
        if(s[i]=='0'||s[i]=='1') {
            n.push({s[i]-'0',0,0});
        }//数字进栈
        else if(s[i]=='(') {
            f.push(s[i]);
        } else if(s[i]=='&')    {
            while(!f.empty()&&f.top()=='&') {
                cul();
            }
            f.push(s[i]);
        } else if(s[i]=='|') {
            while(!f.empty()&&(f.top()=='|'||f.top()=='&')) {
                cul();
            }
            f.push(s[i]);
        } else if(s[i]==')') {
            while(!f.empty()&&f.top()!='(') {
                cul();
            }
            f.pop();
        }
    }
    while(!f.empty()) {
        cul();
    }
}
int main() {
    cin>>s;
    l=strlen(s);
    work();
    number t=n.top();
    cout<<t.num<<endl<<t.op1<<' '<<t.op2;
    return 0;
}

现场真题注意事项

https://cspoj.com/contest.php?cid=1002

Fus5yz4x3EcSJH1Z

注意事项

文件名（程序名和输入输出文件名）必须使用英文小写。（提交必须使用freopen()进行提交）

C/C++ 中函数 main() 的返回值类型必须是 int，程序正常结束时的返回值必须是0。

提交的程序代码文件的放置位置请参考各省的具体要求。

因违反以上三点而出现的错误或问题，申述时一律不予受理。

若无特殊说明，结果的比较方式为全文比较（过滤行末空格及文末回车）。

程序可使用的栈空间内存限制与题目的内存限制一致。

全国统一评测时采用的机器配置为：Inter® Core™ i7-8700K CPU @3.70GHz，内存 32GB。上述时限以此配置为准。

只提供 Linux 格式附加样例文件。

评测在当前最新公布的 NOI Linux 下进行，各语言的编译器版本以此为准

假设输入样例数据存在文件test.in中，输出样例数据存在文件test.out中，

则在CSP、NOI等比赛的代码中，需添加freopen、fclose语句，

内容详见模板代码如下。

#include <bits/stdc++.h>
#include<cstdio>//必须包含cstdio头文件
#include<iostream>
using namespace std;
int main(){
  freopen("test.in","r",stdin);
  freopen("test.out","w",stdout);
  cout<<"Hello NOI"<<endl;
  fclose(stdin);
  fclose(stdout);
  return 0;
}

下面为函数的简介，详细可参见 http://www.cplusplus.com/reference/clibrary/cstdio/freopen.html

函数名：freopen

声明：FILE *freopen( const char *path, const char *mode, FILE *stream );

所在文件： stdio.h

参数说明：

path: 文件名，用于存储输入输出的自定义文件名。

mode: 文件打开的模式。和fopen中的模式（如r-只读, w-写）相同。

stream: 一个文件，通常使用标准流文件。

返回值：成功，则返回一个path所指定文件的指针；失败，返回NULL。（一般可以不使用它的返回值）

功能：实现重定向，把预定义的标准流文件定向到由path指定的文件中。标准流文件具体是指stdin、stdout和stderr。其中stdin是标准输入流，默认为键盘；stdout是标准输出流，默认为屏幕；stderr是标准错误流，一般把屏幕设为默认。通过调用freopen，就可以修改标准流文件的默认值，实现重定向。

#include<iostream>
#include<cstdio>
using namespace std;
int main(){
    freopen("7532.in", "r", stdin);
    freopen("7532.out", "w", stdout);
    //原来的代码保持不变
    double a, b, r;
    int k;
    cin >> a >> b;
    k = int(a/b);
    r = a - b * k;
    printf("%g", r);
    //-------------
    fclose(stdin);
    fclose(stdout);
    return 0;
}

CSP-J第二轮试题-2022年-3题

参考：

总结