CSP-J 2026 第一轮 AI 模拟卷 2

（共 15 题，每题 2 分，共 30 分。每题有且仅有一个正确选项。）

输入字符串只含小写英文字母与字符 `#`，且不以 `#` 开头或结尾，也不存在连续的 `#`。判断题正确填 ✓，错误填 ✗。

 1 | #include <algorithm>
 2 | #include <iostream>
 3 | #include <string>
 4 | using namespace std;
 5 | int main() {
 6 |     string s;
 7 |     cin >> s;
 8 |     string ans, part;
 9 |     int pal = 0;
10 |     for (int i = 0; i <= (int)s.size(); ++i) {
11 |         if (i < (int)s.size() && s[i] != '#') {
12 |             part.push_back(s[i]);
13 |         } else {
14 |             string rev = part;
15 |             reverse(rev.begin(), rev.end());
16 |             if (rev == part) ++pal;
17 |             if (!ans.empty()) ans.push_back('#');
18 |             ans += rev;
19 |             part.clear();
20 |         }
21 |     }
22 |     cout << ans << '\n' << pal << '\n';
23 |     return 0;
24 | }

输入为一个非空小写英文字母串。判断题正确填 ✓，错误填 ✗。

 1 | #include <iostream>
 2 | #include <string>
 3 | using namespace std;
 4 | string fold(const string &s, int l, int r) {
 5 |     if (l > r) return "";
 6 |     if (l == r) return string(1, s[l]);
 7 |     string mid = fold(s, l + 1, r - 1);
 8 |     if (s[l] < s[r])
 9 |         return s[l] + mid + s[r];
10 |     else
11 |         return s[r] + mid + s[l];
12 | }
13 | int main() {
14 |     string s;
15 |     cin >> s;
16 |     cout << fold(s, 0, (int)s.size() - 1) << '\n';
17 |     return 0;
18 | }

输入为一个仅含数字字符的非空字符串，长度不超过 40。程序把它划分成若干个十进制整数，每段必须在 1～26 之间。判断题正确填 ✓，错误填 ✗。

 1 | #include <iostream>
 2 | #include <string>
 3 | #include <vector>
 4 | using namespace std;
 5 | int main() {
 6 |     string s;
 7 |     cin >> s;
 8 |     int n = s.size();
 9 |     vector<long long> dp(n + 1, 0);
10 |     dp[0] = 1;
11 |     for (int i = 1; i <= n; ++i) {
12 |         if (s[i - 1] != '0') dp[i] += dp[i - 1];
13 |         if (i >= 2) {
14 |             int x = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
15 |             if (10 <= x && x <= 26) dp[i] += dp[i - 2];
16 |         }
17 |     }
18 |     cout << dp[n] << '\n';
19 |     return 0;
20 | }

给定两个非空小写字母串 `s` 和 `t`（长度均不超过 30），计算从 `s` 中按原顺序选出若干字符形成 `t` 的方案数。不同下标选择视为不同方案，答案保证在 `long long` 范围内。

#include <iostream>
#include <string>
#include <vector>
using namespace std;
string s, t;
vector<vector<long long>> memo;
long long ways(int i, int j) {
    if (j == (int)t.size()) return ①;
    if (i == (int)s.size()) return ②;
    if (memo[i][j] != -1) return ③;
    long long ans = ways(④, j);
    if (s[i] == t[j]) ans += ways(i + 1, ⑤);
    return memo[i][j] = ans;
}
int main() {
    cin >> s >> t;
    memo.assign(s.size(), vector<long long>(t.size(), -1));
    cout << ways(0, 0) << '\n';
    return 0;
}

给定一个长度为 1～500 的小写字母串，求其最长回文子序列的长度。子序列不要求连续，但必须保持原字符的相对顺序。

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
    string s;
    cin >> s;
    int n = s.size();
    vector<vector<int>> dp(n, vector<int>(n, 0));
    for (int i = 0; i < n; ++i) dp[i][i] = ①;
    for (int len = ②; len <= n; ++len) {
        for (int l = 0; l + len <= n; ++l) {
            int r = ③;
            if (s[l] == s[r])
                dp[l][r] = dp[l + 1][r - 1] + ④;
            else
                dp[l][r] = max(dp[l + 1][r], ⑤);
        }
    }
    cout << dp[0][n - 1] << '\n';
    return 0;
}