信息学奥赛 CSP-J 2025 初赛模拟卷 2

一、单项选择题（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项）

第 1 题 在 C++ 程序中，假设一个字符占用的内存空间是 1 字节，则下列程序中，s 占用的内存空间是 ( ) 字节。

char s[] = "hello csp-j";
size_t cnt = strlen(s);
cout 
#include 
#include 
using namespace std;
using i64 = long long;

int clz(i64 x) {
    for (int i = 0; i != 64; i++) {
        if ((x >> (63 - i)) & 1)
            return i;
    }
    return 64;
}

bool cmp(i64 x, i64 y) {
    if (clz(x) == clz(y))
        return x > n;
    vector a(n);
    for (int i = 0; i > a[i];
    }
    sort(a.begin(), a.end(), cmp);
    for (int i = 0; i `，则当程序输入为 `5 0 4 2 1 3` 时，程序输出为 `4 3 2 1 0`。 ( )
  {{ select(17) }}
  - 对
  - 错

**判断题 18** 当调用 `cmp(3, 3)` 时，函数的返回值为 `false`。 ( )
  {{ select(18) }}
  - 对
  - 错

**选择题 19** 若输入为 `5 4 2 1 3 1`，则输出是什么？( )
  {{ select(19) }}
  - 3 4 2 1 1
  - 3 2 4 1 1
  - 4 3 2 1 1
  - 4 2 3 1 1

**选择题 20** 这个程序实现了什么功能？( )
  {{ select(20) }}
  - 将输入的数组按照二进制位上从左到右第一个 1 前 0 的个数由多到少进行排序
  - 将输入的数组按照二进制位上从左到右第一个 1 前 0 的个数由少到多进行排序
  - 将输入的数组按照二进制位上从左到右第一个 1 前 0 的个数由多到少进行排序，当 0 的个数相同时，按照原数字由小到大进行排序
  - 将输入的数组按照二进制位上从左到右第一个 1 前 0 的个数由少到多进行排序，当 0 的个数相同时，按照原数字由小到大进行排序

### 程序 (2)
```cpp
#include 
#include 
#include 
#include 
#include 
using namespace std;

const int inf = 0x3f3f3f3f;

int calc(vector> &grid) {
    int m = grid.size(), n = grid[0].size();
    vector> dp(m + 1, vector(n + 1, inf));
    dp[0][0] = grid[0][0];
    for (int i = 0; i  0)
                dp[i][j] = min(dp[i][j], dp[i - 1][j] + grid[i][j]);
            if (j > 0)
                dp[i][j] = min(dp[i][j], dp[i][j - 1] + grid[i][j]);
        }
    }
    return dp[m - 1][n - 1];
}

int main() {
    int m, n;
    cin >> m >> n;
    vector> a(m, vector(n));
    for (int i = 0; i > a[i][j];
        }
    }
    cout 
#include 
#include 
#include 
#include 
using namespace std;

const int N = 1010;
vector E[N];
int V[N];
int n;

void add(int x, int y) {
    E[x].push_back(y);
}

int gcd(int x, int y) {
    return !y ? x : gcd(y, x % y);
}

void calc(int cur, int fa) {
    V[cur] = (gcd(cur, fa) != 1);
    for (auto v : E[cur]) {
        if (v == fa)
            continue;
        calc(v, cur);
        V[cur] += V[v];
    }
}

int main() {
    cin >> n;
    for (int i = 1; i > x >> y;
        add(x, y);
        add(y, x);
    }
    calc(1, 1);
    for (int i = 1; i 
using namespace std;
using i64 = long  long;

void solve() {
    int n, flag = 0, mx = ①;
    cin >> n;
    vector a(n + 1);
    for (int i = 1; i > a[i];
        if (a[i] > t;
    while (t--) {
        solve();
    }
    return 0;
}

选择题 33 ①处应填 ( ) {{ select(33) }}

• 0
• 1E9
• -1E8
• -2E9

选择题 34 ②处应填 ( ) {{ select(34) }}

• flag == n
• flag == 0
• flag != 0
• flag != n

选择题 35 ③处应填 ( ) {{ select(35) }}

• int
• i64
• double
• unsigned int

选择题 36 ④处应填 ( ) {{ select(36) }}

• sum2 += max(a[i], 0)
• sum2 += min(a[i], 0)
• sum2 -= min(a[i], 0)
• sum2 -= max(a[i], 0)

选择题 37 ⑤处应填 ( ) {{ select(37) }}

• min(sum1, sum2)
• max(sum1, sum2)
• sum1 + sum2
• sum1 - sum2

题目 (2)

题目描述：给定一个字符串 t 和一个字符串列表 s 作为字典。保证 s 中的字符串互不相同，且 t 和 s[i] 中均只包含小写英文字母。如果可以利用字典中出现的一个或多个单词拼接出 t，则返回 true。注意：不要求字典中出现的单词全部使用，并且字典中的单词可以重复使用。

数据限制：1 ≤ t.length() ≤ 300 , 1 ≤ s.size() ≤ 1000, 1 ≤ s[i].length() ≤ 20。

#include 
#include 
#include 
#include 
#include 
using namespace std;

const int N = 100005;

int n, mx, m;
vector s;
vector mem;
string t;
set st;

int dfs(int i) {
    if (i == 0)
        return 1;
    if (①)
        return mem[i];
    for (int j = i - 1; j >= max(i - mx, ⑦); j--) {
        if (st.find(②) != st.end() && dfs(j))
            return mem[i] = 1;
    }
    return ③;
}

int main() {
    cin >> n;
    s.resize(n);
    for (int i = 0; i > s[i];
        mx = max(mx, ④);
    }
    st = set(s.begin(), s.end());
    cin >> t;
    m = (int)t.length();
    mem.resize(m + 1, -1);
    if (⑤)
        cout << "Yes\n";
    else
        cout << "No\n";
    return 0;
}

选择题 38 ①处应填 ( ) {{ select(38) }}

• mem[i] != -1
• mem[i] == -1
• mem[i] == 0
• mem[i] != 0

选择题 39 ②处应填 ( ) {{ select(39) }}

• t.substr(i, j - i)
• t.substr(j, i - j)
• t.substr(j)
• t.substr(i)

选择题 40 ③处应填 ( ) {{ select(40) }}

• 1
• 0
• -1
• mem[i]

选择题 41 ④处应填 ( ) {{ select(41) }}

• s[i].length()
• (int)s[1].length()
• s[i].length() - 1
• (int)s[i].length() - 1

选择题 42 ⑤处应填 ( ) {{ select(42) }}

• !dfs(m)
• !dfs(n)
• dfs(m)
• dfs(n)