2022 CSP-J题解

$T1, T2$ 不讲

T3: 逻辑表达式

$20$ 分做法：$|s| \leqslant 3$ 的时候能满足的字符串很少只有 a|b，a&b， a，b 四种。$|s| \leqslant 5$ 的时候再加上a|b|c，a|b&c，a&b|c，a&b&c 这四种，把八种情况分别计算就能拿到 $20$ 分。

$50$ 分做法：考虑 $|s| \leqslant 2000$ 的情况，我们可以建出表达式树，递归求解答案

$85$ 分做法：对于特殊性质 $1$，我们可以从左往右处理，看这样一个例子 0|(1|0)|(0|(1|0)), 遇到左括号：如果 | 的左边是 $1$ 就直接跳到对应右括号，如果 | 的左边是 $0$ 就递归到下一层

$100$ 分做法：本题是一道模拟题，含括号的表达式求值，一般可以使用递归或栈模拟。

中缀表达式转后缀表达式

代码实现

#include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
 
struct Node {
    int v, cOr, cAnd;
    Node() {}
    Node(int v=0, int cOr=0, int cAnd=0): v(v), cOr(cOr), cAnd(cAnd) {}
};
 
int getPriority(char op) {
    if (op == '(') return 0;
    if (op == '|') return 1;
    return 2;
}
 
string inToPost(string s) {
    stack<char> stk;
    string res;
    for (int c : s) {
        if (c == '(') stk.push('(');
        else if (c == ')') {
            while (stk.top() != '(') {
                res += stk.top();
                stk.pop();
            }
            stk.pop();
        }
        else if (c == '&' or c == '|') {
            while (stk.size() and getPriority(c) <= getPriority(stk.top())) {
                res += stk.top();
                stk.pop();
            }
            stk.push(c);
        }
        else res += c;
    }
    while (stk.size()) {
        res += stk.top();
        stk.pop();
    }
    return res;
}
 
int main() {
    string s;
    cin >> s;
    
    string t = inToPost(s);
    stack<Node> stk;
    for (char c : t) {
        if (c == '|') {
            auto [v1, cOr1, cAnd1] = stk.top(); stk.pop();
            auto [v2, cOr2, cAnd2] = stk.top(); stk.pop();
            stk.emplace(v2|v1, cOr2+(v2==1?1:cOr1), cAnd2+(v2==1?0:cAnd1));
        }
        else if (c == '&') {
            auto [v1, cOr1, cAnd1] = stk.top(); stk.pop();
            auto [v2, cOr2, cAnd2] = stk.top(); stk.pop();
            stk.emplace(v2&v1, cOr2+(v2==0?0:cOr1), cAnd2+(v2==0?1:cAnd1));
        }
        else stk.emplace(c-'0', 0, 0);
    }
    
    auto [v, cOr, cAnd] = stk.top();
    cout << v << '\n';
    cout << cAnd << ' ' << cOr << '\n';
    
    return 0;
}

T4：上升点列

$40$ 分做法：$k = 0$ 时，可用类似最长上升子序列的做法处理

$50$ 分做法：当 $x_i$ 和 $y_i$ 比较小的时候，我们可以把它当成一个棋盘 $dp$，如果这个坐标有对应的点那么代价为 $0$，否则代价为 $1$，任意点都能作为起点，枚举终点，求出代价小于 $k$ 的时候到达终点的最长路。可以通过 $1 \sim 7$ 和 $11 \sim 15$ 的测试点。

$75$ 分做法：再考虑 $k = 0$ 的情况，只能连续选择，把每个点按照横坐标排序，然后枚举每个点 $i$，$i$ 只能接在坐标小于 $i$ 且曼哈顿距离为 $1$ 的点 $j$ 后面，$dp[i] = \max(dp[j] +1)$。可以通过 $8 \sim 10$ 的测试点。

$100$ 分做法：考虑到添加的 $k$ 个点是自由的，我们可以用这 $k$ 个点来填补曼哈顿距离大于 $1$ 的相邻点，如果两个点之间没有相邻点，并且它们的曼哈顿距离是 $d$，那么需要填充 $d-1$ 个点，才能把这两个点同时选出来。整个序列最多填充 $k$ 个点。
我们可以把填充的点数当做选择相邻两个点的代价，那么这道题就转化成在 $n$ 个点选出总代价不超过 $k$ 的序列，要求序列最长，就变成一个子序列问题了。
子序列的另一个要求是横坐标、纵坐标均单调不减，我们把 $n$ 个点按 $x$ 坐标排序，枚举当前点之前的所有点，再判断 $y$ 坐标是否小于等于当前点即可。
使用动态规划求解子序列问题，记 dp[i][j] 表示在排序后的前 $i$ 个点中，选出代价为 $j$ 的子序列，能得到的序列的最长长度。
转移方程：

$$dp[i][j] = \max\{dp[t][j-(d-1)]+d\}$$

其中 $t$ 的取值范围是 $1 \sim i-1$，$d$ 是 $t$ 点与 $i$ 点的曼哈顿距离。

需要注意，最后 $k$ 个点一定全部都会用上，如果求出序列没有用上所有的 $k$ 个点，那么可以把剩下的 $k$ 个点直接加在最后一个点后面。

时间复杂度：$O(n^2k)$

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define x first
#define y second
 
using namespace std;
using P = pair<int, int>;
 
int dp[505][105];
 
inline void chmax(int& x, int y) { if (x < y) x = y; }
 
int main() {
    int n, k;
    cin >> n >> k;
    
    vector<P> ps(n);
    rep(i, n) cin >> ps[i].x >> ps[i].y;
    
    sort(ps.begin(), ps.end());
    
    int ans = 0; 
    rep(i, n) {
        rep(j, k+1) {
            dp[i][j] = j+1;
            rep(t, i) if (ps[t].y <= ps[i].y) {
                int d = (ps[i].x-ps[t].x) + (ps[i].y-ps[t].y);
                int nj = j-d+1;
                if (nj >= 0) chmax(dp[i][j], dp[t][nj]+d);
            }
        }
        chmax(ans, dp[i][k]);
    }
    
    cout << ans << '\n';
    
    return 0;
}