2022 CSP-J 第二轮认证真题解析

✨：2022 CSP-J 第二轮认证真题解析

💟：幸愉编程

💜: 学习如逆水行舟，不进则退 💜💜

🌸: 如有错误或不足之处，希望可以指正，非常感谢😉

[CSP-J 2022] T1 乘方

题目描述

小文同学刚刚接触了信息学竞赛，有一天她遇到了这样一个题：给定正整数 $a$ 和 $b$ ，求 $a^b$ 的值是多少。

$a^b$ 即 $b$ 个 $a$ 相乘的值，例如 $2^3$ 即为 $3$ 个 $2$ 相乘，结果为 $\times 2 \times2$ = $8$ 。

“简单！”小文心想，同时很快就写出了一份程序，可是测试时却出现了错误。

小文很快意识到，她的程序里的变量都是 int 类型的。在大多数机器上， $in t$ 类型能表示的最大数为 $2^{31}$ - $1$ ，因此只要计算结果超过这个数，她的程序就会出现错误。

由于小文刚刚学会编程，她担心使用 $in t$ 计算会出现问题。因此她希望你在 $a^b$ 的值超过 ${10}^9$ 时，输出一个 $- 1$ 进行警示，否则就输出正确的 $a^b$ 的值。

然而小文还是不知道怎么实现这份程序，因此她想请你帮忙。

输入格式

输入共一行，两个正整数 $a$ , $b$ 。

输出格式

输出共一行，如果 $a^b$ 的值不超过 ${10}^9$ ，则输出 $a^b$ 的值，否则输出 $- 1$ 。

样例

输入样例1

10 9

输出样例1

1000000000

输入样例2

23333 66666

输出样例2

-1

提示/说明

对于 $\%$ 的数据，保证 $b = 1$ 。
对于 $\%$ 的数据，保证 $\le 2$ 。
对于 $\%$ 的数据，保证 $\le 30b$ ， $a^b \le {10}^{18}$
对于 $\%$ 的数据，保证 $\le a, b \le {10}^9$

解析

思路

判断一下 $a^2$ 的最小值大于 $10^9$ ，化解出 a大于等于31700时最后的结果一定大于 $10^9$ ，然后写个快速幂求 $a^b$ ，特判结果是否可能大于 $10^9$ ，大于 $10^9$ 返回 -1，否则返回结果，骗分大法是直接读取后输出 -1 可以拿 $25\%$ 的分数，简单送分题。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL quick_pow(LL a, LL b){
    if(b>=2 && a >= 31700) return -1;
    LL res = 1;
    while(b > 0){
        if(b&1) res *= a;
        a = a*a;
        b >>= 1;
        if(res > 1e9) return -1;
    }
    return res;
}
int main()
{
    int a, b;
    cin>>a>>b;
    cout<<quick_pow(a, b);
    return 0;
}

[CSP-J 2022] T2 解密

题目描述

给定一个正整数 $k$ ，有 $k$ 次询问，每次给定三个正整数 $n_i$ , $e_i$ , $d_i$ ，求两个正整数 $p_i$ , $q_i$ ，使 $n_i = p_i \times q_i$ 、 $e_i \times d_i = (p_i - 1)(q_i - 1) + 1$ 。

输入格式

第一行一个正整数 $k$ ，表示有 $k$ 次询问。
接下来 $k$ 行，第 $i$ 行三个正整数 $n_i$ , $d_i$ , $e_i$ 。

输出格式

输出 $k$ 行，每行两个正整数 $p_i, q_i$ 表示答案。
为使输出统一，你应当保证 $p_i \leq q_i$ 。
如果无解，请输出 $NO$ 。

输入样例

输出样例

2 385
NO
NO
NO
11 78
3 241
2 286
NO
NO
6 88

提示/说明

【数据范围】
以下记 $\times d + 2$ 。
保证对于 $100\%$ 的数据， $\leq k \leq {10}^5$ ，对于任意的 $\leq i \leq k$ ， $\leq n_i \leq {10}^{18}$ ， $\leq e_i \times d_i \leq {10}^{18}$ ， $\leq m \leq {10}^9$ 。

测试点编号	$k \leq$	$n \leq$	$m \leq$	特殊性质
$1$	$10^3$	$10^3$	$10^3$	保证有解
$2$	$10^3$	$10^3$	$10^3$	无
$3$	$10^3$	$10^9$	$6\times10^4$	保证有解
$4$	$10^3$	$10^9$	$6\times10^4$	无
$5$	$10^3$	$10^9$	$10^9$	保证有解
$6$	$10^3$	$10^9$	$10^9$	无
$7$	$10^5$	$10^{18}$	$10^9$	保证若有解则 $p = q$
$8$	$10^5$	$10^{18}$	$10^9$	保证若有解
$9$	$10^5$	$10^{18}$	$10^9$	无
$10$	$10^5$	$10^{18}$	$10^9$	无

解析

解题思路

∵ $e d = (p - 1) (q - 1) + 1$
∴ $e d = pq - p - q + 2$
∵ $pq = n$
∴ $e d = n - p - q + 2$

$p + q = n - e d + 2$ ( $n$ 、 $e$ 、 $d$ 是已知量)
$n - e d + 2$ 则可以求出，令其为 $k$
将 $p = k - q$ ( $p \leq q$ ) 代入 $pq = n$
( $k - q) q = n$ ==> $q^2 + kq - n = 0$

一元二次方程求根公式：形如 $ax^2 + bx + c = 0$

$x = (-b ± √b^2 - 4ac)$

$q^2 - kq + n = 0 ==> x = (-k ±√k^2 - 4n)$
题目要求 $p$ 、 $q$ 是正整数，所以 $Δ < 0$ 或者 $\sqrtΔ \in / Z$ 无解，否则输出 $p$ 和 $q$ 的值。

数学代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL n, k, e, d, m, p, q;
int main () {
    cin >> k;
    while (k-- ){
        cin >> n >> d >> e;
        m = n - e * d + 2;
        LL tmp = m*m - 4*n;
        if(tmp < 0 || (LL)sqrt(tmp)*(LL)sqrt(tmp) != tmp){
            cout<<"NO"<<endl;
            continue;
        }
        tmp = (LL)sqrt(tmp);
        cout << (m-tmp)/2 << ' ' << (m+tmp)/2 <<endl;
    }
    return 0;
}

二分代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL n, k, e, d;
int main () {
    cin >> k;
    while (k -- ) {
        cin >> n >> d >> e;
        LL k = n - e * d + 2;
        LL l = 1, r = k, p, q;
        while (l < r) {
            p = (l + r) / 2;
            q = k - p;
            if (n == p * q) break;
            else if (n <= p * q) r = p;
            else l = p + 1;
        }
        if (n == p * q){
            if(p <= q)
                cout << p << ' ' << q << endl;
            else 
                cout<< q << ' ' << p << endl;
        } 
        else cout << "NO" << endl;
    }
    return 0;
}

[CSP-J 2022] T3 逻辑表达式

题目描述

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

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

$\mathbin{\&} 0 = 0 \mathbin{\&} 1 = 1 \mathbin{\&} 0 = 0$ 。， $\mathbin{\&} 1 = 1$ ；
$\mathbin{|} 0 =0，0 \mathbin{|} 1 = 1 \mathbin{|} 0 = 1 \mathbin{|}1 = 1$ 。

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

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

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

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

输入格式

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

输出格式

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

样例

输入样例1

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

输出样例1

1
1 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

【数据范围】
设 $∣ s ∣$ 为字符串 $s$ 的长度。

对于所有数据， $1≤|s|≤10^6$ 。保证 $s$ 中仅含有字符 $0$ 、 $1$ 、 $\&$ 、 $∣$ 、 $($ 、 $)$ 且是一个符合规范的逻辑表达式。

保证输入字符串的开头、中间和结尾均无额外的空格。

保证 $s$ 中没有重复的括号嵌套（即没有形如 $((a))$ 形式的子串，其中 $a$ 是符合规范的逻辑表达式）。
在这里插入图片描述
其中：
特殊性质 $1$ 为：保证 $s$ 中没有字符 &。

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

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

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

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

解析

思路

中缀表达式转后缀表达式，开个 $p ai r$ 记录 a&b 和 a|b 短路次数即可。

代码

#include <bits/stdc++.h>
#define f first
#define s second
using namespace std;
stack<char> op;
stack<int> num;
stack<pair<int,int>> res;
void work()
{
    int a = num.top(); num.pop();  //靠右的数
    int b = num.top(); num.pop();  //靠左的数
    pair<int,int> c, d;
    c = res.top(), res.pop();  // 靠右的数的记录
    d = res.top(), res.pop();  // 靠左的数的记录
    
    char x = op.top(); op.pop(); // 操作符号
    if(x == '&'){
        num.push(a & b);
        if(b == 0){ //短路
            res.push({d.f + 1, d.s});
        }else{
            res.push({d.f + c.f, d.s + c.s});
        }
    }
    if(x == '|'){
        num.push(a | b);
        if(b == 1){
            res.push({d.f, d.s + 1});
        }else{
            res.push({d.f+c.f, d.s + c.s});
        }
    }
    
}
int main()
{
    unordered_map<int,int>p{{'&', 2}, {'|', 1}};  //设置优先级
    string str;
    cin>>str;
    for(int i = 0; i < str.size(); i++){
        auto x = str[i];
        if(x >= '0' && x <= '9'){
            int y = x - '0';
            num.push(y);
            res.push({0, 0});
        }
        else if(x == '(') op.push(x);  //左括号
        else if(x == ')')  //右括号
        {
            while(op.top() != '('){
                work();
            }
            op.pop();
        }
        else  //运算符
        {
            while(!op.empty() && p[op.top()] >= p[x]) work();
            op.push(x);
        }
    }
    //剩余运算符
    while(!op.empty()) work();
    printf("%d\n",num.top());
    printf("%d %d\n",res.top().f, res.top().s);
    return 0;
}

[CSP-J 2022]T4 上升点列

题目描述

在一个二维平面内，给定 $n$ 个整数点 ( $x_i, y_i$ )，此外你还可以自由添加 $k$ 个整数点。

你在自由添加 $k$ 个点后，还需要从 $n + k$ 个点中选出若干个整数点并组成一个序列，使得序列中任意相邻两点间的欧几里得距离恰好为 $1$ 而且横坐标、纵坐标值均单调不减，即 $x_{i+1} - x_i = 1, y_{i+1} = y_i$ 或 $y_{i+1} - y_i = 1$ , $x_{i+1} = x_i$ 。请给出满足条件的序列的最大长度。

输入格式

第一行两个正整数 $n, k$ 分别表示给定的整点个数、可自由添加的整点个数。
接下来 $n$ 行，第 $i$ 行两个正整数 $x_i, y_i$ 表示给定的第 $i$ 个点的横纵坐标。

输出格式

输出一个整数表示满足要求的序列的最大长度。

样例

输入样例1

输出样例1

输入样例2

输出样例2

提示/说明

【数据范围】
保证对于所有数据满足： $\leq n \leq 500$ ， $\leq k \leq 100$ 。对于所有给定的整点，其横纵坐标 $\leq x_i, y_i \leq {10}^9$ ，且保证所有给定的点互不重合。对于自由添加的整点，其横纵坐标不受限制。
在这里插入图片描述

解析

思路

floyd 求两点之间最少需要的桥梁个数，distance 函数求第 $i$ 个点到第 j 个点之间连接起来需要几个桥梁。第 $i$ 个点到第 $j$ 个点最少需要的桥梁个数小于等于允许添加的桥梁个数，最后比较更新一下最大值即可。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int x[501],y[501];
LL d[501][501];
int distance(int i,int j)
{
    return abs(x[i]-x[j])+abs(y[i]-y[j]);
}
void floyd() //多源最短路径
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
}
int main()
{
    cin>>n>>k;
    for(int i = 1; i <= n; i++)cin>>x[i]>>y[i];
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++){
            if(i != j && x[i] <= x[j] && y[i] <= y[j])
                d[i][j] = distance(i, j) - 1;
            else d[i][j] = 2147483647;
        }
    floyd();
    LL res = 0;
    for(int i = 1;i <= n; i++)
        for(int j = 1; j <= n; j++)
            if(d[i][j] <= k)
                res = max(res, distance(i,j) - d[i][j] + k + 1);
    cout<<res;
}

结语

由于忙于考教资和考研的事情，题目一直没有去做，做完后第一题可以使用快速幂快速求，暴力枚举问题也不大；第二题二分或者韦达定理；第三题最难，中缀转后缀表达式；第四题可以套个 floyed 或者使用动态规划解决，参考最长上升子序列，2023祝大家 RP++。