集训安排：

必讲内容：

1、加乘原理、排列组合、容斥原理

2、时间复杂度 2、冒泡、插入、选择 2、尺取

3、常见贪心 3、前缀和及变种

4、进制转换 4、素数判断及优化、因数求和及优化 4、gcd、lcm 4、素数筛、倍数枚举

5、二分查找、不同类型查找、开闭区间、应用

选讲内容：

1、常见二分答案 2、枚举 3、模拟 4、递推

题目名后缀：

小迪-0000

王老师-1000

文老师-2000

梁老师-3000

菠萝-4000

叶老师-5000

潘老师-6000

考点：

1、重点算法：

数位分离（叶）

连续性问题（潘）√

下标计数（梁）

枚举（梁）

模拟（叶）

冒泡、插入、选择排序（潘）

简单数论（因数、倍数、gcd、lcm、素数判断）（潘、叶、梁）

常见贪心（部分背包问题、活动选择问题、排序部分求和问题、分组安排问题，其它的随机）（小迪）

尺取（菠萝）

进制转换（菠萝）

前缀和（文、王）

二分查找（文、王）

二分答案（文、王）

简单递推（斐波那契及变种）（文、王）

素数筛、倍数枚举（文、王）

2、重点补充知识：

计算机知识（潘、叶、梁）

C++语法描述（潘、叶、梁）

C++常用函数（菠萝）

字符串函数（菠萝）

时间复杂度（文、王）

排列组合、容斥原理（常见和简单的）（文、王）

出题要求

1. 每一道题尽量单独一个题目
2. 题目加上标签“市赛,2026市赛”
3. 出完题目后需要在“评测设置”里把题型改为 “客观题”
4. 题目不需要隐藏
5. 一个考点按 10 ~ 15 道单选题，2 道阅读程序题，2 道完善程序题的规模出题

题目模板

单选题模板：

1. 计算机内控制和计算的硬件是 {{ select(1) }}
  - CPU
  - 内存
  - 硬盘
  - 键盘

答案：A

注意选项前的 - 前的 tab 最多一个，多了不行

阅读程序题模板：

```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1000010];
int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	int maxCnt = 1;
	int cnt = 1;
	for (int i = 2; i <= n; i++) {
		if (a[i] > a[i - 1]) {
			cnt++;
		}
		else {
			// (1)
			cnt = 1;
		}
		maxCnt = max(maxCnt, cnt);
	}
	cout << maxCnt;
	return 0;
}
```
## 判断题
1. 若输入 `6 1 2 1 2 2 4`，则输出 4 {{ select(1) }}
  - 对
  - 错
3. 程序的功能为：求最大连续上升段的长度 {{ select(2) }}
  - 对
  - 错
4. 把 `maxCnt = max(maxCnt, cnt);` 改到 (1) 位置程序也是正确的 {{ select(3) }}
  - 对
  - 错

## 选择题
4. 若输入 `5 1 2 2 3 4`，则输出 {{ select(4) }}
  - 2
  - 3
  - 4
  - 5

5. 若把程序中的部分语句修改，仍能实现相同效果的是 {{ select(5) }}
  - 把 `i = 2` 改为 `i = 1`
  - 把 `a[i] > a[i - 1]` 改为 `a[i] < a[i + 1]`
  - 把 `int maxCnt = 1;` 改为 `int maxCnt = 0;`
  - 把 `for (int i = 2; i <= n; i++)` 改为 `for (int i = n; i > 1; i--)`

6. 上述程序不可以解决 `n` 为多大的问题 {{ select(6) }}
  - $1 \leq n \leq 10^9$
  - $1 \leq n \leq 10^6$
  - $1 \leq n \leq 10^4$
  - $1 \leq n \leq 100$

答案：

BAB

BDA

完善程序题模板：

题目描述：最短覆盖子串

给定一个长度为 n (1 ≤ n ≤ 10^5) 的整数序列 a[]，序列中所有元素的值在 1 到 m 之间（m ≤ n）。
再给定一个长度为 k (1 ≤ k ≤ m) 的“目标集合” b[]，b 中元素互不相同。

要求：找到一个最短的连续子段，使得该子段包含 b 中的所有元素至少一次。
如果不存在，输出 0。

输入：

第一行 n m k

第二行 n 个整数，表示 a[]

第三行 k 个整数，表示 b[]

输出：

最短子段长度

示例：

输入：

10 5 3

1 3 2 5 4 3 2 1 5 3

2 3 5

输出：

3

```cpp
#include <iostream>
using namespace std;
const int MAXN = 100005;
int a[MAXN];
bool need[MAXN];
int cnt[MAXN];
int main() {
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    for (int i = 0; i <= m; i++) {
        need[i] = false;
    }
    for (int i = 0; i < k; i++) {
        int x;
        cin >> x;
        need[x] = true;
    }
    int left = 0;
    int satisfied = 0;
    int min_len = n + 1;
    for (int right = 0; right < n; right++) {
        if (need[a[right]]) {
            cnt[a[right]]++;
            if (_____(1)_____) {
                satisfied++;
            }
        }
        while (_____(2)_____ && left <= right) {
            int cur_len = _____(3)_____;
            if (cur_len < min_len) {
                min_len = cur_len;
            }
            if (need[a[left]]) {
                cnt[a[left]]--;
                if (cnt[a[left]] == 0) {
                    _____(4)_____;
                }
            }
            _____(5)_____;
        }
    }
    if (min_len == n + 1) {
        cout << 0 << endl;
    } else {
        cout << min_len << endl;
    }
    return 0;
}
```

1. 程序第 (1) 处应填入？ {{ select(1) }}
  - `cnt[a[right]] == 1`  
  - `cnt[a[right]] > 0`  
  - `cnt[a[right]] == 0`  
  - `a[right] == need[a[right]]`

2. 程序第 (2) 处应填入？ {{ select(2) }}
  - `satisfied < k`  
  - `satisfied == k`  
  - `left < right`  
  - `cnt[a[left]] > 0`

3. 程序第 (3) 处应填入？ {{ select(3) }}
  - `right - left`  
  - `right - left + 1`  
  - `right - left - 1`  
  - `left - right + 1`

4. 程序第 (4) 处应填入？ {{ select(4) }}
  - `satisfied++`  
  - `satisfied--`  
  - `satisfied = 0`  
  - `satisfied = cnt[a[left]]`

5. 程序第 (5) 处应填入？ {{ select(5) }}
  - `right++`  
  - `left++`  
  - `left--`  
  - `satisfied++`

答案：ABBBB