GESP C++ 六级 · 14 天闯关
非线性结构 · 树图搜索与面向对象
7 天理论 + 7 天编程题:前 7 天把本级别考点的 近 12 期真题 180 道全部刷完(含 29 道需要看原卷配图的题), 后 7 天按知识点分天练编程题(洛谷题面 + 美力程题解),共 28 道; 末尾附 1 套模拟自测卷。
理论天含:① 今日考情(真题分布 + 配套教材)→ ② 知识地图(思维导图)→ ③ 核心精讲 → ④ 真题演练(本考点全部真题,10 题/卡)→ ⑤ 今日打卡。 编程天按知识点分组(如「图案输出 · 嵌套循环画图」一天),题面取洛谷、题解取美力程。 单选答案已与官方答案表逐题核对。进度保存在本机浏览器。
树与二叉树
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 62 道客观题(单选 62 / 判断 0,其中 10 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023-09 | 3 |
| 2023-12 | 5 |
| 2024-03 | 4 |
| 2024-06 | 3 |
| 2024-09 | 7 |
| 2024-12 | 5 |
| 2025-03 | 5 |
| 2025-06 | 5 |
| 2025-09 | 6 |
| 2025-12 | 7 |
| 2026-03 | 6 |
| 2026-09 | 6 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.1 树与二叉树的遍历。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
第六章最重的一块,真题占比超过三分之一,而且几乎全是「给你一棵树,问你遍历序列」。必须练到**给任意两个序列能画出树、给树能写出三个序列**。三条口诀要先背下来:**前序定根、中序分左右、后序的最后一个也是根**。完全二叉树的编号规律(左孩子 2i、右孩子 2i+1、父 ⌊i/2⌋)必考。
②知识地图 · 本考点思维导图
- 基本概念
- 根、叶子、父结点、子结点、兄弟
- 结点的度 = 子结点个数
- 树的深度(高度)= 最大层数
- n 个结点的树有 n−1 条边
- 二叉树性质
- 第 k 层最多 2^(k−1) 个结点
- 深度 h 的二叉树最多 2^h − 1 个结点
- 叶子数 n0 = 度为 2 的结点数 n2 + 1
- 编号从 1 起:左孩子 2i、右孩子 2i+1、父 ⌊i/2⌋
- 三种深度优先遍历
- 前序:根 → 左 → 右
- 中序:左 → 根 → 右
- 后序:左 → 右 → 根
- 层序遍历
- 用队列,一层一层出
- 由序列还原树
- 前序 + 中序 → 唯一确定
- 后序 + 中序 → 唯一确定
- 层序 + 中序 → 唯一确定
- 前序 + 后序 → **不能**唯一确定
- 特殊二叉树
- 满二叉树:每层都填满
- 完全二叉树:只有最后一层可缺,且靠左连续
- 二叉排序树 BST:左 < 根 < 右,中序即升序
- 哈夫曼树:带权路径长度 WPL 最小
- 哈夫曼编码
- 每次取权值最小的两个合并
- 左 0 右 1(或相反,不影响长度)
- 是前缀编码,解码无歧义
③核心精讲
1. 二叉树的五条性质
| 性质 | 内容 |
|---|---|
| 第 k 层结点数 | 最多 2^(k−1)(根为第 1 层) |
| 深度 h 的总结点数 | 最多 2^h − 1 |
| 叶子与二度结点 | n0 = n2 + 1 |
| 完全二叉树编号 | 左孩子 2i、右孩子 2i+1、父 ⌊i/2⌋ |
| 树与边 | n 个结点有 n−1 条边 |
验证 n0 = n2 + 1:一棵只有根结点的树,n0=1, n2=0,成立; 给任意叶子加两个子结点,叶子数 +1、二度结点数 +1,等式仍成立。
2. 三种遍历:递归定义
void preorder(Node *r) { // 前序:根 左 右
if (!r) return;
cout << r->val << " ";
preorder(r->left);
preorder(r->right);
}
void inorder(Node *r) { // 中序:左 根 右
if (!r) return;
inorder(r->left);
cout << r->val << " ";
inorder(r->right);
}
void postorder(Node *r) { // 后序:左 右 根
if (!r) return;
postorder(r->left);
postorder(r->right);
cout << r->val << " ";
}
「前中后」说的是「根」在第几个被访问,左右顺序永远是先左后右。
以这棵树为例:
A
/ \
B C
/ \ \
D E F
| 遍历 | 序列 |
|---|---|
| 前序 | A B D E C F |
| 中序 | D B E A C F |
| 后序 | D E B F C A |
| 层序 | A B C D E F |
3. 由两个序列还原树(必考)
核心口诀:
- 前序的第一个是根;
- 后序的最后一个是根;
- 找到根在中序里的位置,左边是左子树、右边是右子树。
例题:前序 A B D E C F,中序 D B E A C F。
第 1 步:前序第一个是 A → A 是根
第 2 步:中序里 A 的下标是 3 → 左边 D B E 是左子树、右边 C F 是右子树
第 3 步:左子树的前序是 B D E(前序里 A 后面 3 个)
B 是左子树的根;中序 D B E 中 B 在中间 → D 左、E 右
第 4 步:右子树的前序是 C F,中序是 C F
C 是根;中序里 C 在最左 → C 没有左子树,F 是右孩子
还原结果:
A
/ \
B C
/ \ \
D E F
唯一性:前序+中序 ✅、后序+中序 ✅、层序+中序 ✅、前序+后序 ❌。 原因:前序和后序都只能定「根」,定不了左右子树的分界。 反例:
A有两个孩子B、C,前序A B C、后序B C A; 但「B 是左孩子、C 是右孩子」和「B 是右孩子、C 是左孩子」两个序列完全一样。
4. 层序遍历:用队列
void levelOrder(Node *root) {
if (!root) return;
queue<Node*> q;
q.push(root);
while (!q.empty()) {
Node *cur = q.front(); q.pop();
cout << cur->val << " ";
if (cur->left) q.push(cur->left);
if (cur->right) q.push(cur->right);
}
}
5. 完全二叉树
定义:除最后一层外每层都填满,且最后一层的结点全部靠左连续。
完全二叉树 ✅ 非完全二叉树 ❌
1 1
/ \ / \
2 3 2 3
/ \ / \
4 5 4 6
为什么完全二叉树能用数组存:编号连续,a[1] 是根,a[2i] 是左孩子, a[2i+1] 是右孩子,不需要指针。
含 n 个结点的完全二叉树高度 = ⌊log₂n⌋ + 1。 n=7 → ⌊2.8⌋+1 = 3 层。
易错:完全二叉树 ≠ 满二叉树。满二叉树要求每层都填满, 完全二叉树只要求「靠左连续」。满二叉树一定是完全二叉树,反过来不成立。
6. 哈夫曼树与哈夫曼编码
构造:每次从集合里取权值最小的两个,合并成一个新结点(权值相加),放回集合,重复到只剩一个。
例:权值 1, 2, 3, 4。
第 1 步:取 1、2 → 合并成 3 集合 {3, 3, 4}
第 2 步:取 3、3 → 合并成 6 集合 {4, 6}
第 3 步:取 4、6 → 合并成 10 完成
WPL(带权路径长度)= 每个叶子的权值 × 它的深度,求和:
1×3 + 2×3 + 3×2 + 4×1 = 3 + 6 + 6 + 4 = 19
哈夫曼编码:从根出发,向左走记 0、向右记 1,到叶子的路径就是该字符的编码。
因为所有字符都在叶子上,任何一个编码都不可能是另一个的前缀 → 这就是前缀编码,解码时不会产生歧义。
| 概念 | 要点 |
|---|---|
| 哈夫曼树 | WPL 最小的二叉树 |
| 哈夫曼编码 | 变长前缀编码,高频字符编码短 |
| 格雷编码 | 相邻两数只差一位,用于减少传输错误 |
- 1.B 在二叉搜索树(BST)中,若中序遍历的序列为{1, 2, 3, 4,…
- 2.B 有关下图的二叉树,说法正确的是( )。…
- 3.B 基于第4题的定义,有关下面C++代码的说法正确的是( )。…
- 4.D 下面有关树的存储,错误的是( ).…
- 5.B 一个有 124 个叶子节点的完全二叉树,最多有( )个结点。…
- 6.A 若一棵二叉树的先序遍历为:A, B, D, E, C, F、中序遍历…
- 7.A 二叉树的( )第一个访问的节点是根节点。…
- 8.A 一棵5层的满二叉树中节点数为( )。…
- 9.A 给定一棵二叉树,其前序遍历结果为:ABDECFG,中序遍历结果为:D…
- 10.C 一棵有个结点的完全二叉树用数组进行存储与表示,已知根结点存储在数组的…
bool isCompleteTree(TreeNode* root) {
if (root == nullptr) return true;
queue<TreeNode*> q;
q.push(root);
bool hasNull = false;
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
if (node == nullptr) {
hasNull = true;
} else {
if (hasNull) return false;
q.push(node->left);
q.push(node->right);
}
}
return true;
}bool check(TreeNode* root) {
if (!root) return true;
queue<TreeNode*> q;
q.push(root);
bool hasNull = false;
while (!q.empty()) {
TreeNode* cur = q.front(); q.pop();
if (!cur) {
hasNull = true;
} else {
if (hasNull) return false;
q.push(cur->left);
q.push(cur->right);
}
}
return true;
}bool find(Node* root, int x) {
while (root) {
if (root->val == x) return true;
root = (x < root->val) ? root->left : root->right;
}
return false;
}- 11.B 以下关于完全二叉树的代码描述,正确的是( )。…
- 12.B ( )只有最底层的节点未被填满,且最底层节点尽量靠左填充。…
- 13.D 在使用数组表示完全二叉树时,如果一个节点的索引为(从开始计数),那么…
- 14.D 已知一棵二叉树的前序遍历序列为 GDAFEMHZ ,中序遍历序列为 …
- 15.A 已知二叉树的 中序遍历 是 [D, B, E, A, F, C],先…
- 16.A 完全二叉树可以用数组连续高效存储,如果节点从1 开始编号,则对有两个…
- 17.B 以下函数 check() 用于判断一棵二叉树是否为( )。…
- 18.B 在二叉排序树(Binary Search Tree, BST)中,假…
- 19.A 某二叉树共有10个结点,记为A~J,已知它的先序遍历序列为:A B …
- 20.A 已知一棵二叉树的先序遍历序列为 A B D E C F ,中序遍历序…
void traverse(TreeNode* root) {
if (!root) return;
traverse(root->left);
traverse(root->right);
cout << root->val << " ";
}void visit(TreeNode *root) {
if (root == nullptr)
return;
visit(root->left);
cout << root->val << " ";
visit(root->right);
}#include <iostream>
using namespace std;
// 遍历二叉搜索树,输出结点值
void traversal(tree_node* root) {
if (root == nullptr) {
return;
}
traversal(root->left);
cout << root->val << " ";
traversal(root->right);
} ABCD
/ \
A BCD
/ \
D BC
/ \
B C
ABCD
/ \
A BCD
/ \
B CD
/ \
C D
ABCD
/ \
D ABC
/ \
A BC
/ \
B C
ABCD
/ \
C ABC
/ \
B AD
/ \
A D#include <iostream>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* search(TreeNode* root, int val) {
cout << root->val << " ";
if (root == NULL || root->val == val) return root;
if (val < root->val)
return search(root->left, val);
else
return search(root->right, val);
}
5
/ \
3 7
/ \ / \
2 4 6 8struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* createTree() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
return root;
}- 21.A 在二叉排序树(Binary Search Tree, BST)中查找…
- 22.A 在构建哈夫曼树时,每次应该选择( )合并。…
- 23.B 以下关于树的说法,( )是正确的。…
- 24.C 以下代码实现了二叉树的( )。…
- 25.B 下列函数实现了二叉树的哪种遍历方式( )。…
- 26.B 对上题中的二叉搜素树,当输入数组为时,构建二叉搜索树,并采用如下代码…
- 27.A 已知字符集 {A, B, C, D} 的出现频率如下表所示: 字符频…
- 28.B 根据下面二叉树和给定的代码, 给定以下二叉搜索树,调用函数 sear…
- 29.B 以下函数createTree() 构造的树是什么类型?…
- 30.B 对 个不同符号的符号进行哈夫曼编码。若生成的哈夫曼树共有 个结点,则…
a: 010 b: 011 c: 00 d: 10 e: 11 a: 00 b: 10 c: 011 d: 100 e: 111 a: 10 b: 01 c: 011 d: 100 e: 111 a: 100 b: 01 c: 011 d: 100 e: 00
// 定义二叉树的结点结构
struct tree_node {
int val;
tree_node* left;
tree_node* right;
tree_node(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 计算二叉树的深度
int max_depth(tree_node* root) {
if (root == nullptr) {
return 0; // 如果根结点为空,则深度为 0
}
int left_depth = max_depth(root->left);
int right_depth = max_depth(root->right);
———————————————————————— // 在此处填入代码
}#include <queue>
int max_depth_bfs(tree_node* root) {
if (root == nullptr) {
return 0; // 如果树为空,深度为 0
}
queue <tree_node*> q;
q.push(root);
int depth = 0;
// 使用队列进行层序遍历
while (!q.empty()) {
———————————————————————— // 在此处填入代码
for (int i = 0; i < level_size; ++i) {
tree_node* node = q.front();
q.pop();
if (node->left) {
q.push(node->left);
}
if (node->right) {
q.push(node->right);
}
}
}
return depth;
} 1
/ \
2 3
/ \ \
8 9 6
/ \ \
4 5 7- 31.B 对 hello world 使用霍夫曼编码(Huffman Codi…
- 32.C 对“classmycls”使用哈夫曼(Huffman)编码,最少需要…
- 33.C 上一题中各字符的哈夫曼编码是( )。…
- 34.B 给定字符集 {A, B, C, D} 的出现频率分别为 {5, 1,…
- 35.A 设有字符集 {a, b, c, d, e},其出现频率分别为 {5,…
- 36.B 以下关于哈夫曼编码的说法,正确的是( )。…
- 37.B 有关下面C++代码不正确的说法是( )。…
- 38.C 二叉树的深度定义为从根结点到叶结点的最长路径上的结点数,则以下基于二…
- 39.A 上一题的二叉树深度计算还可以采用二叉树的广度优先搜索来实现。以下基于…
- 40.C 使用上题中的宽度优先搜索算法遍历以下这棵树,可能的输出是( )。…
#include <vector>
#include <queue>
#include <algorithm>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
vector<int> largestValues(TreeNode* root) {
vector<int> result;
if (!root) return result;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
int sz = q.size();
int maxVal = INT_MIN;
for (int i = 0; i < sz; ++i) {
TreeNode* node;
_______________________________
maxVal = max(maxVal, node->val);
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
result.push_back(maxVal);
}
return result;
}
node = q.end();
node = q.front();
q.pop();
node = q.front();
node = q.front();
q.pop();struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
void dfs(TreeNode* root) {
if (!root) return;
______<TreeNode*> temp; // 在此处填写代码
temp.push(root);
while (!temp.empty()) {
TreeNode* node = temp.top();
temp.pop();
cout << node->val << " ";
if (node->right) temp.push(node->right);
if (node->left) temp.push(node->left);
}
}struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
void dfs(TreeNode* root) {
if (!root) return;
stack<TreeNode*> st;
st.push(root);
while (!st.empty()) {
TreeNode* node = st.top(); st.pop();
cout << node->val << " ";
if (node->right) st.push(node->right);
________________________
}
}int height(TreeNode *root) {
if (root == nullptr)
return 0;
int leftH = height(root->left);
int rightH = height(root->right);
return __________________________;
}TreeNode* search(TreeNode* root, int target) {
if (root == NULL || root->val == target) {
return root;
}
if (_______________) {
return search(root->left, target);
} else {
return search(root->right, target);
}
}// 定义二叉树的结点结构
struct tree_node {
int val;
tree_node* left;
tree_node* right;
tree_node(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 插入结点到二叉搜索树中
tree_node* insert(tree_node* root, int val) {
if (root == nullptr) {
return new tree_node(val);
}
———————————————————————— // 在此处填入代码
return root;
}
// 根据给定数组构造二叉搜索树
tree_node* constructBST(const int arr[], int size) {
tree_node* root = nullptr;
for (int i = 0; i < size; ++i) {
root = insert(root, arr[i]);
}
return root;
}
if (val < root->val)
root->left = insert(root->left, val);
else
root->right = insert(root->right, val);
if (val > root->val)
root->left = insert(root->left, val);
else
root->right = insert(root->right, val);
if (val < root->val)
root->left = insert(root, val);
else
root->right = insert(root, val);
if (val > root->val)
root->left = insert(root, val);
else
root->right = insert(root, val);- 41.D 给定一个二叉树,返回每一层中最大的节点值,结果以数组形式返回,横线处…
- 42.D 请将下列树的深度优先遍历代码补充完整,横线处应填入( )。…
- 43.A 下列代码实现了树的深度优先遍历,则横线处应填入( )。…
- 44.C 下列关于树的遍历的说法中,正确的一项是( )。…
- 45.C 下列关于树的深度优先搜索(DFS)的说法中,正确的是( )。…
- 46.D 下面函数用于计算二叉树的高度,横线处应填写( )。…
- 47.C 个节点的二叉搜索树,其查找的平均时间复杂度为( )。…
- 48.A 构造二叉树 [1,2,3,null,4] ( )。…
- 49.B 以下代码希望能在一棵二叉排序树中搜索特定的值,请在横线处填入( ),…
- 50.A 二叉搜索树中的每个结点,其左子树的所有结点值都小于该结点值,右子树的…
void traverse(TreeNode* root) {
if (root == nullptr) return;
cout << root->val << " ";
traverse(root->left);
traverse(root->right);
}TreeNode* op(TreeNode* root, int val) {
if (root == nullptr) return new TreeNode(val);
if (val < root->val) {
root->left = op(root->left, val);
} else {
root->right = op(root->right, val);
}
return root;
}struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
TreeNode* deleteNode(TreeNode* root, int key) {
if (!root) return nullptr;
if (key < root->val) {
root->left = deleteNode(root->left, key);
}
else if (key > root->val) {
root->right = deleteNode(root->right, key);
}
else {
if (!root->left) return root->right;
if (!root->right) return root->left;
TreeNode* temp = ____________; // 在此处填写代码
root->val = temp->val;
root->right = deleteNode(root->right, temp->val);
}
return root;
}TreeNode* op(TreeNode* root, int x) {
if (!root) return new TreeNode(x);
if (x < root->val)
root->left = op(root->left, x);
else
root->right = op(root->right, x);
return root;
}struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
TreeNode* bfsFind(TreeNode* root, int x) {
if (!root) return nullptr;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* cur = q.front(); q.pop();
if (cur->val == x) return cur;
________________________
}
return nullptr;
}
if (cur->left)
q.push(cur->left);
if (cur->right)
q.push(cur->right);
q.push(cur->left);
q.push(cur->right);void dfs(TreeNode *root) {
if (root == nullptr)
return;
stack<TreeNode *> s;
s.push(root);
while (!s.empty()) {
TreeNode *node = s.top();
s.pop();
cout << node->value << " ";
———————————————————————— // 在此处填入代码
}
}
s.push(node->right);
s.push(node->left);
s.push(node->left);
s.push(node->right);
if (node->right)
s.push(node->right);
if (node->left)
s.push(node->left);
if (node->left)
s.push(node->left);
if (node->right)
s.push(node->right);TreeNode *searchBST(TreeNode *root, int x) {
if (root == nullptr || root->val == x)
return root;
if (x < root->val)
return searchBST(root->left, x);
return __________________________;
}- 51.B 哈夫曼编码是一种数据压缩算法。以下关于哈夫曼编码的描述中,不正确的是…
- 52.A 以下代码实现了树的哪种遍历方式?…
- 53.B 以下代码实现了二叉排序树的哪种操作?…
- 54.C 删除二叉排序树中的节点时,如果节点有两个孩子,则横线处应填入( ),…
- 55.B 以下函数实现了二叉排序树(BST)的( )操作。 第 6 页 / 共…
- 56.C 给定一棵普通二叉树(节点值没有大小规律),下面代码判断是否存在值为 …
- 57.C 以下代码实现二叉树左子树优先的深度优先搜索算法,则横线上应填写( )…
- 58.B 下面函数在二叉搜索树中查找值 x 。横线处应填写( )。…
- 59.B 有 个字符,其出现频率分别为 、、、、。按哈夫曼算法构造编码树,其最…
- 60.B 某内容仅会出现ABCDEFG ,其对应的出现概率为0.40、0.30…
- 61.B 假设字母表{a,b,c,d,e} 在字符串出现的频率分别为 10%,…
- 62.D 有6 个字符,它们出现的次数分别为:{2, 3, 3, 4, 6, …
④今日打卡 · 点一下就能勾选
- 默写二叉树五条性质,验证 n0 = n2 + 1
- 给一棵 7 个结点的树写出前序、中序、后序、层序四个序列
- 由前序 ABDECF 与中序 DBEA CF 还原树,写出完整过程
- 说明为什么「前序 + 后序」不能唯一确定二叉树,给反例
- 写出层序遍历的队列实现
- 对权值 1/2/3/4 构造哈夫曼树,算出 WPL 与各字符编码
- 把本日 62 道客观题做完,错题标记出来
栈与队列的进阶应用
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 20 道客观题(单选 20 / 判断 0,其中 1 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2024-03 | 2 |
| 2024-06 | 2 |
| 2024-09 | 4 |
| 2024-12 | 1 |
| 2025-03 | 2 |
| 2025-06 | 1 |
| 2025-09 | 2 |
| 2025-12 | 1 |
| 2026-03 | 2 |
| 2026-09 | 3 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.2 哈夫曼树与哈夫曼编码。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
六级把栈和队列从「知道 LIFO/FIFO」升级成「会用它们解题」。真题最爱考的三种:**括号匹配**(栈)、**表达式求值**(栈)、**BFS 的队列**、**单调栈/单调队列**。循环队列的判空判满公式是纯记忆题,一定要背准。
②知识地图 · 本考点思维导图
- 栈(LIFO,后进先出)
- 操作:push / pop / top / empty
- 只在一端(栈顶)进出
- 应用一:括号匹配
- 应用二:表达式求值 / 后缀表达式
- 应用三:函数调用栈、DFS
- 应用四:单调栈(下一个更大元素)
- 队列(FIFO,先进先出)
- 操作:push / pop / front / back
- 队尾进、队头出
- 应用一:BFS 层序遍历
- 应用二:滑动窗口最大值(单调队列)
- 循环队列
- 判空:front == rear
- 判满:(rear + 1) % MAX == front
- 牺牲一个单元来区分空与满
- 优先队列
- priority_queue,堆实现
- 默认大根堆;小根堆用 greater<int>
- 插入/删除 O(log n),取顶 O(1)
- 栈与队列的互相实现
- 两个栈实现一个队列
- 两个队列实现一个栈
③核心精讲
1. 栈:括号匹配
bool check(string s) {
stack<char> st;
for (char c : s) {
if (c == '(' || c == '[' || c == '{') {
st.push(c); // 左括号入栈
} else {
if (st.empty()) return false; // 右括号多了
char t = st.top();
if ((c == ')' && t != '(') ||
(c == ']' && t != '[') ||
(c == '}' && t != '{')) return false;
st.pop(); // 配对成功,弹出
}
}
return st.empty(); // 左括号多了也会 false
}
为什么用栈:括号的配对是「后出现的先闭合」,正好是 LIFO。
2. 栈:后缀表达式求值
后缀表达式(逆波兰式)把运算符写在两个操作数之后:3 4 + 表示 3 + 4。
int eval(vector<string> &tok) {
stack<int> st;
for (string &t : tok) {
if (t == "+" || t == "-" || t == "*" || t == "/") {
int b = st.top(); st.pop(); // 注意:先出的是右操作数
int a = st.top(); st.pop();
if (t == "+") st.push(a + b);
else if (t == "-") st.push(a - b);
else if (t == "*") st.push(a * b);
else st.push(a / b);
} else {
st.push(stoi(t));
}
}
return st.top();
}
易错:减法与除法有顺序,先弹出的是右操作数
b。 写成a - b而不是b - a,这是六级阅读程序的高频陷阱。
手推 3 4 + 5 * :
| 读到 | 栈 |
|---|---|
| 3 | [3] |
| 4 | [3, 4] |
| + | [7] |
| 5 | [7, 5] |
| * | [35] |
3. 单调栈:下一个更大元素
// 对每个位置求「右边第一个比它大的数的下标」,没有则 -1
vector<int> nextGreater(vector<int> &a) {
int n = a.size();
vector<int> res(n, -1);
stack<int> st; // 存下标,栈内对应值单调递减
for (int i = 0; i < n; i++) {
while (!st.empty() && a[st.top()] < a[i]) {
res[st.top()] = i; // 找到了
st.pop();
}
st.push(i);
}
return res;
}
每个元素最多进栈一次、出栈一次 → O(n)。
4. 循环队列
用数组实现时,front == rear 既可能是空也可能是满,所以牺牲一个存储单元:
const int MAX = 100;
int q[MAX], front = 0, rear = 0;
bool empty() { return front == rear; }
bool full() { return (rear + 1) % MAX == front; }
void push(int x) { q[rear] = x; rear = (rear + 1) % MAX; }
int pop() { int x = q[front]; front = (front + 1) % MAX; return x; }
| 状态 | 判据 |
|---|---|
| 空 | front == rear |
| 满 | (rear + 1) % MAX == front |
| 元素个数 | (rear - front + MAX) % MAX |
5. 优先队列
priority_queue<int> pq; // 大根堆,堆顶最大
priority_queue<int, vector<int>, greater<int>> q2; // 小根堆,堆顶最小
pq.push(3); pq.push(9); pq.push(1);
cout << pq.top(); // 9
| 操作 | 复杂度 |
|---|---|
取堆顶 top() | O(1) |
插入 push() | O(log n) |
删除堆顶 pop() | O(log n) |
6. 两个栈实现队列
思路:in 栈负责进,out 栈负责出。出队时若 out 为空,就把 in 全部倒过去(顺序就正了)。
stack<int> in, out;
void push(int x) { in.push(x); }
int pop() {
if (out.empty())
while (!in.empty()) { out.push(in.top()); in.pop(); }
int x = out.top(); out.pop(); return x;
}
关键点:只在 out 为空时才倒,否则顺序会乱。每个元素最多被倒一次 → 均摊 O(1)。
#include <iostream>
#include <stack>
#include <string>
using namespace std;
bool is_valid(string s) {
stack<char> st;
char top;
for (char& ch : s) {
if (ch == '(' || ch == '{' || ch == '[') {
st.push(ch); // 左括号入栈
}
else
{
if (st.empty())
return false;
———————————————————————— // 在此处填入代码
if ((ch == ')' && top != '(') ||
(ch == '}' && top != '{') ||
(ch == ']' && top != '[')) {
return false;
}
}
}
return st.empty(); // 栈为空则说明所有括号匹配成功
}bool isBalanced(string s) {
stack<char> st;
for (char c : s) {
if (c == '(' || c == '[' || c == '{') {
st.push(c);
} else {
if (st.empty()) return false; // 无左括号匹配
char top = st.top();
st.pop();
if ((c == ')' && top != '(') ||
(c == ']' && top != '[') ||
(c == '}' && top != '{')) {
return false;
}
}
}
return ________________; //在此处填入代码
}#include <iostream>
using namespace std;
stack<int> ten2bin(int n) {
stack<int> st;
int r, m;
r = n % 2;
m = n / 2;
st.push(r);
while (m != 1) {
r = m % 2;
st.push(r);
m = m / 2;
}
st.push(m);
return st;
}
int main() {
int n;
cin >> n;
stack<int> bin;
bin = ten2bin(n);
while (!bin.empty()) {
_____________________ // 在此处填入代码
}
return 0;
}#include <iostream>
#include <vector>
#include <string>
using namespace std;
// 生成 n 位的格雷码
vector<string> generate_graycode(int n) {
vector<string> graycode_list;
if (n <= 0) {
return graycode_list;
}
// 初始1位格雷码
graycode_list.push_back("0");
graycode_list.push_back("1");
// 迭代生成 n 位的格雷码
for (int i = 2; i <= n; i++) {
int current_size = graycode_list.size();
for (int j = current_size - 1; j >= 0; j--) {
graycode_list.push_back("1" + graycode_list[j]);
}
for (int j = 0; j < current_size; j++) {
———————————————————————— // 在此处填入代码
}
}
return graycode_list;
}void processData() {
stack<int> s;
queue<int> q;
for (int i = 1; i <= 5; ++i) {
s.push(i);
q.push(i);
}
while (!s.empty()) {
cout << "Stack pop: " << s.top() << endl;
s.pop();
}
while (!q.empty()) {
cout << "Queue pop: " << q.front() << endl;
q.pop();
}
}vector<string> generateGrayCode(int n) {
if (n == 0) return {"0"};
if (n == 1) return {"0", "1"};
vector<string> prev = generateGrayCode(n - 1);
vector<string> result;
for (string s : prev) {
result.push_back("0" + s); // 在前缀添加 0
}
for (int i = prev.size() - 1; i >= 0; i--) {
———————————————————————— // 在此处填入代码
}
return result;
}- 1.A 采用如下代码实现检查输入的字符串括号是否匹配,横线上应填入的代码为(…
- 2.C 以下代码用于检查字符串中的括号是否匹配,横线上应填写( )。…
- 3.A 在队列中,元素的添加和删除是按照( )原则进行的。…
- 4.D 给定一个空栈,执行以下操作序列: 操作序列:push(1), pus…
- 5.B 在栈数据结构中,元素的添加和删除是按照什么原则进行的?…
- 6.A 要实现将一个输入的十进制正整数转化为二进制表示,下面横线上应填入的代…
- 7.C 有6个元素,按照 6,5,4,3,2,1 的顺序进入栈S,下列( )…
- 8.B 以下C++代码实现位的格雷码,则横线上应填写( )。…
- 9.B 阅读以下代码,下面哪一项是正确的?…
- 10.A 以下代码用于生成 位格雷编码。横线上应填写( )。…
stack<int> s;
queue<int> q;
for (int i = 1; i <= 3; ++i) {
s.push(i);
q.push(i);
}
cout << s.top() << " " << q.front() << endl;vector<string> grayCode(int n) {
if (n == 0) return {"0"};
if (n == 1) return {"0", "1"};
vector<string> prev = grayCode(n-1);
vector<string> result;
for (string s : prev) {
result.push_back("0" + s);
}
for (_______________) { // 在此处填写代码
result.push_back("1" + prev[i]);
}
return result;
}const int MAX = 5;
int queue[MAX];
int front = 0, rear = 0;
// 入队
void enqueue(int x) {
queue[rear] = x;
rear = (rear + 1) % MAX;
}
// 出队
void dequeue() {
front = (front + 1) % MAX;
}
int main() {
enqueue(1); enqueue(2); enqueue(3); enqueue(4);
dequeue(); dequeue();
enqueue(5); enqueue(6);
}stack<int> s;
queue<int> q;
for (int i = 2; i <= 6; i += 2) {
s.push(i);
q.push(i);
}
s.pop();
q.pop();
cout << s.top() << " " << q.front();const int MAXN = 8;
int data[MAXN];
int front = 0, rear = 0;
bool full() {
return __________________________;
}vector<string> gray(int n) {
vector<string> ans = {"0", "1"};
for (int bit = 2; bit <= n; ++bit) {
int oldSize = ans.size();
for (int i = oldSize - 1; i >= 0; --i)
ans.push_back(__________________________);
for (int i = 0; i < oldSize; ++i)
ans[i] = "0" + ans[i];
}
return ans;
}#include <iostream>
#include <queue>
using namespace std;
bool is_front_equal(std::queue<int>& q, int a) {
bool is_equal = false;
if (!q.empty()) {
———————————————————————— // 在此处填入代码
}
return is_equal;
}- 11.B 以下关于栈和队列的代码,执行后输出是( )。…
- 12.B 栈的操作特点是( )。…
- 13.B 下面代码生成格雷编码,则横线上应填写( )。…
- 14.A 某文本编辑器把用户输入的字符依次压入栈 S。用户依次输入 A , B…
- 15.A 游乐园的过山车每次限坐 4 人,用循环队列管理排队(容量 MAX=5…
- 16.D 在以下计算机系统应用场景中,最适合使用循环队列的是( )。…
- 17.B 下列代码执行后的输出结果是( )。…
- 18.C 下面循环队列采用“空出一个位置”的方式区分队空和队满。横线处应填写(…
- 19.C 下面代码用反射法生成 n 位格雷编码,横线处应填写( )。…
- 20.B 下面代码判断队列的第一个元素是否等于,并删除该元素,横向上应填写( …
④今日打卡 · 点一下就能勾选
- 写出括号匹配的栈实现,说明为什么必须用栈
- 手推 3 4 + 5 * 的求值过程,说明为什么先弹出的是右操作数
- 写出单调栈求「下一个更大元素」,说明为什么是 O(n)
- 默写循环队列的判空、判满、元素个数三个公式
- 说明循环队列为什么要牺牲一个存储单元
- 写出两个栈实现队列的 push/pop,说明均摊复杂度
- 把本日 20 道客观题做完,错题标记出来
面向对象:类与对象
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 31 道客观题(单选 31 / 判断 0,其中 6 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023-09 | 8 |
| 2023-12 | 6 |
| 2024-03 | 1 |
| 2024-06 | 1 |
| 2024-09 | 2 |
| 2024-12 | 3 |
| 2025-03 | 3 |
| 2025-06 | 1 |
| 2025-09 | 2 |
| 2025-12 | 1 |
| 2026-03 | 2 |
| 2026-09 | 1 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.3 完全二叉树与二叉排序树。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
面向对象是六级的分水岭,也是很多学 C 出身的同学最陌生的一块。真题的考法很固定:**给一段类定义,问输出什么 / 哪个选项编译错**。抓住三条就不会错:**private 外部不可访问**、**构造函数的调用时机与顺序**、**成员函数默认是 this 调用**。
②知识地图 · 本考点思维导图
- 类与对象的关系
- 类是模板,对象是按模板造出来的实例
- 一个类可以造很多对象
- 访问权限
- public:谁都能访问
- private:只有类自己的成员函数能访问
- protected:自己 + 派生类
- class 默认 private,struct 默认 public
- 构造函数
- 名字与类名相同、**没有返回类型**
- 对象创建时自动调用
- 可以重载(多个版本)
- 默认构造:无参数版本
- 初始化列表:ClassName() : a(0), b(0) {}
- 析构函数
- 名字是 ~类名、没有参数、没有返回值
- 对象销毁时自动调用
- 用来释放 new 出来的资源
- 成员函数与 this
- 成员函数可以直接访问成员变量
- this 指向「调用这个函数的对象」
- 静态成员
- static 成员属于类,不属于某个对象
- 所有对象共享一份
- 类外要再定义一次
- 运算符重载
- operator+ / operator< 等
- 封装
- 数据私有、接口公开
- 好处:外部改不坏内部状态
③核心精讲
1. 类的定义与访问权限
class Student {
private: // 私有:外部不能碰
int score;
public: // 公开:外部可以调用
void setScore(int s) { score = s; } // 成员函数内部可以访问 private
int getScore() { return score; }
};
int main() {
Student a;
a.setScore(95); // ✅ 通过公开接口
cout << a.getScore(); // 95
// a.score = 95; // ❌ 编译错误:private 不可访问
}
class 与 struct 的唯一区别:
class默认private,struct默认public。 其他完全一样(struct 也能有成员函数、也能继承)。
2. 构造函数:没有返回类型
class Point {
int x, y;
public:
Point() { x = 0; y = 0; } // 默认构造
Point(int a, int b) { x = a; y = b; } // 带参构造(重载)
Point(int a) : x(a), y(0) {} // 初始化列表
};
Point p1; // 调用 Point()
Point p2(3, 4); // 调用 Point(int, int)
Point p3(5); // 调用 Point(int)
四条铁律:
- 构造函数名与类名相同;
- 没有返回类型,连
void都不写; - 创建对象时自动调用,不能手动调;
- 可以重载多个版本。
易错:写了
void Point() {}不是构造函数,是一个普通成员函数。 这个点经常作为选择题的错误选项。
3. 初始化列表
class A {
const int c;
int &r;
public:
A(int v, int &ref) : c(v), r(ref) {} // 只能用初始化列表
};
必须用初始化列表的三种情况:
const成员(定义后不能赋值)- 引用成员(定义时必须绑定)
- 没有默认构造函数的成员对象
初始化顺序由成员在类里声明的顺序决定,不由初始化列表的书写顺序决定——这是常考陷阱。
4. 析构函数
class Buffer {
int *data;
public:
Buffer(int n) { data = new int[n]; }
~Buffer() { delete[] data; } // 对象销毁时自动调用
};
| 特征 | 构造函数 | 析构函数 |
|---|---|---|
| 名字 | 类名 | ~类名 |
| 参数 | 可以有 | 不能有 |
| 返回值 | 无 | 无 |
| 重载 | 可以 | 不可以 |
| 调用时机 | 对象创建 | 对象销毁 |
5. this 指针
class Counter {
int n;
public:
void inc() { this->n++; } // this 指向调用它的那个对象
Counter& add(int v) {
n += v;
return *this; // 返回自身,支持链式调用
}
};
this 就是「当前对象」的地址。成员函数里写 n 和写 this->n 等价。
6. 静态成员
class Cat {
public:
static int count; // 声明
Cat() { count++; }
};
int Cat::count = 0; // 类外必须再定义一次(并初始化)
Cat a, b, c;
cout << Cat::count; // 3 所有对象共享同一份
| 类型 | 归属 | 访问方式 |
|---|---|---|
| 普通成员变量 | 每个对象各一份 | obj.x |
| 静态成员变量 | 整个类共一份 | Cat::count 或 obj.count |
| 静态成员函数 | 属于类 | 不能访问非静态成员(没有 this) |
7. 运算符重载
class Vec {
public:
int x, y;
Vec operator+(const Vec &o) const {
return Vec{x + o.x, y + o.y};
}
};
Vec a{1, 2}, b{3, 4};
Vec c = a + b; // c = {4, 6}
8. 封装的意义
把数据设为 private、只暴露必要的接口,好处是:
- 外部改不坏内部状态(比如分数不能被设成负数,可以在
setScore里加检查); - 内部实现可以换,外部代码不用动。
#include <iostream>
using namespace std;
class my_class {
public:
static int count;
my_class() {
count++;
}
~my_class() {
count--;
}
static void print_count() {
cout << count << " ";
}
};
int my_class::count = 0;
int main() {
my_class obj1;
my_class::print_count();
my_class obj2;
obj2.print_count();
my_class obj3;
obj3.print_count();
return 0;
}#include <iostream>
using namespace std;
class MyClass {
public:
MyClass() {
cout << "Constructor called!" << endl;
}
void display() {
cout << "Display function called!" << endl;
}
};
int main() {
MyClass* obj = NULL;
obj->display();
return 0;
}class MyClass {
public:
MyClass() {
cout << "Constructor called!" << endl;
}
};
int main() {
MyClass obj1;
MyClass obj2 = obj1;
return 0;
}class Machine {
protected:
string id;
public:
Machine(string s) : id(s) {}
};
class Robot : public Machine {
int level;
public:
Robot(string s, int n) : __________, level(n) {}
};- 1.D 下面有关C++类定义的说法,错误的是( )。…
- 2.A 有关下面C++代码的说法,错误的是( )。…
- 3.C 以下关于C++中类的说法,哪一项是正确的?…
- 4.A 下列关于 C++ 中类的描述,正确的是( )。…
- 5.D 关于C++语言,以下说法不正确的是( )。…
- 6.B 运行下列代码,屏幕上输出( )。…
- 7.C 以下C++代码段中存在语法错误或逻辑错误,( )是正确的。…
- 8.A 以下代码中,类的构造函数被调用了( )次。…
- 9.A 下列代码中,横线处应填写( ),才能正确调用基类的带参数构造函数。…
- 10.D 有关下面C++代码的说法,正确的是( )。…
class Circle {
private:
double radius;
public:
Circle(double r) : radius(r) {}
double getArea() {
return 3.14 * radius * radius;
}
};- 11.B 有关下面C++代码的说法,错误的是( )。…
- 12.A 近年来,线上授课变得普遍,很多有助于改善教学效果的设备也逐渐流行,其…
- 13.D 如果a 和b 均为int 类型的变量,且b 的值不为0 ,那么下列能…
- 14.D 以下不属于面向对象程序设计语言的是( )。…
- 15.D 关于C++类和对象的说法,错误的是( )。…
- 16.C 有关下面C++代码的说法,错误的是( )。…
- 17.A 下面有关布尔类型的函数的说法,正确的是( )。…
- 18.C 小杨想编写一个判断任意输入的整数N是否为素数的程序,下面哪个方法不合…
- 19.B 内排序有不同的类别,下面哪种排序算法和冒泡排序是同一类?( )…
- 20.D 给定一个简单的类定义如下,( )语句在类的外部正确地创建了一个 Ci…
#include <iostream>
using namespace std;
class Base {
private:
int a;
protected:
int b;
public:
int c;
Base() : a(1), b(2), c(3) {}
};
class Derived : public Base {
public:
void show() {
cout << a << endl; // Line 1
cout << b << endl; // Line 2
cout << c << endl; // Line 3
}
};class CircularQueue {
int* arr;
int front, rear, size;
public:
CircularQueue(int k) {
size = k;
arr = new int[k];
front = rear = -1;
}
bool enQueue(int value) {
if (isFull()) return false;
if (isEmpty()) front = 0;
rear = (rear + 1) % size;
arr[rear] = value;
return true;
}
};class Animal {
public:
std::string name;
Animal(std::string str) : name(str) {
std::cout << "Animal created\n";
}
virtual void speak() {
cout << "Animal speaks" << endl;
}
};
class Dog : public Animal {
std::string breed;
public:
Dog(std::string name, std::string b) : _________________, breed(b) {
std::cout << "Dog created\n";
}
void speak() override {
cout << "Dog barks" << endl;
}
};
int main() {
Animal* p = new Dog("Rex", "Labrador");
p->speak();
delete p;
return 0;
}class Vehicle {
private:
string brand;
public:
Vehicle(string b) : brand(b) {}
void setBrand(const string& b) { brand = b; }
string getBrand() const { return brand; }
void move() const {
cout << brand << " is moving..." << endl;
}
};
class Car : public Vehicle {
private:
int seatCount;
public:
Car(string b, int seats) : Vehicle(b), seatCount(seats) {}
void showInfo() const {
cout << "This car is a " << getBrand()
<< " with " << seatCount << " seats." << endl;
}
};struct Symbol {
char ch; //字符
long long freq; //频率
string code; //哈夫曼编码
};
struct Node {
long long w; //权值
int l, r; //左右孩子(节点下标),-1 表示空
int sym; // 叶子对应符号下标;内部节点为 -1
Node(long long _w=0, int _l=-1, int _r=-1, int _sym=-1)
: w(_w), l(_l), r(_r), sym(_sym) {}
};
// 从 A(leafIdx) 和 B(internalIdx) 的队首取最小的一个节点下标
static int PopMinNode(const vector<Node>& nodes,
const vector<int>& leafIdx, int n, int& pA,
const vector<int>& internalIdx, int& pB) {
if (pA < n && (pB >= (int)internalIdx.size() ||
nodes[leafIdx[pA]].w <= nodes[internalIdx[pB]].w)) {
return leafIdx[pA++];
}
else {
return internalIdx[pB++];
}
}
// DFS 生成编码(左 0,右 1)
static void DFSBuildCodes(int u, const vector<Node>& nodes, Symbol sym[], string& path) {
if (u == -1) return;
if (nodes[u].sym != -1) { // 叶子
sym[nodes[u].sym].code = path;
return;
}
path.push_back('0');
DFSBuildCodes(nodes[u].l, nodes, sym, path);
path.pop_back();
path.push_back('1');
DFSBuildCodes(nodes[u].r, nodes, sym, path);
path.pop_back();
}
int BuildHuffmanCodes(Symbol sym[], int n) {
for (int i = 0; i < n; i++) sym[i].code.clear();
if (n <= 0) return -1;
// 只有一个字符:约定编码为 "0"
if (n == 1) {
sym[0].code = "0";
return 0;
}
vector<Node> nodes;
nodes.reserve(2 * n);
// 1) 建立叶子节点
vector<int> leafIdx(n);
for (int i = 0; i < n; i++) {
leafIdx[i] = (int)nodes.size();
nodes.push_back(Node(sym[i].freq, -1, -1, i));
}
// 2) 叶子按权值排序(A 队列)
sort(leafIdx.begin(), leafIdx.end(),
[&](int a, int b) {
if (nodes[a].w != nodes[b].w) return nodes[a].w < nodes[b].w;
return nodes[a].sym < nodes[b].sym; // 稳定一下
});
// B 队列(内部节点下标队列)
vector<int> internalIdx;
internalIdx.reserve(n);
int pA = 0, pB = 0;
// 3) 合并 n-1 次
for (int k = 1; k < n; k++) {
int x = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);
int y = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);
int z = (int)nodes.size();
________________________ // 在此处填写代码
}
int root = internalIdx.back();
// 4) DFS 生成编码
string path;
DFSBuildCodes(root, nodes, sym, path);
return root;
}
nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, -1));
internalIdx.push_back(z);
nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, -1));
leafIdx.push_back(z);
internalIdx.push_back(z);
nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, x+y));
nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, x+y));
leafIdx.push_back(z);class Pet {
public:
Pet(string n, int a) : name(n), age(a) {}
string getName() { return name; }
void birthday() { age++; }
private:
string name;
int age;
};
int main() {
Pet cat("奶茶", 2);
cout << cat.getName(); // ①
cat.birthday(); // ②
cat.name = "大橘"; // ③
cout << cat.getName(); // ④
}- 21.B 以下( )没有涉及 C++ 语言的面向对象特性支持。…
- 22.A 关于以下C++代码,( )行代码会引起编译错误。…
- 23.D 面向对象编程(OOP)是一种特殊的程序设计方法。下面( )不是重要的…
- 24.D 在面向对象编程中,类是一种重要的概念。下面关于类的描述中,不正确的是…
- 25.A 以下代码实现了循环队列的哪种操作?…
- 26.A 2. 为了让 Dog 类的构造函数能正确地调用其父类 Animal …
- 27.A 假设变量veh 是类Car 的一个实例,我们可以调用veh.move…
- 28.A 下面代码实现了哈夫曼编码,则横线处应填写的代码是( )。 第 4 页…
- 29.C 下面的代码在 main() 中有一行会导致编译错误,请找出来。…
- 30.D 有关下面C++代码的说法,错误的是( )。…
- 31.B 设有字符集{a, b, c, d, e, f} ,其出现频率分别为 …
④今日打卡 · 点一下就能勾选
- 写出一个带 private 数据和 public 接口的类,说明封装的好处
- 列举构造函数的四条铁律,指出 void Point() 为什么不是构造函数
- 说明哪三种成员必须用初始化列表,为什么
- 对比构造与析构的调用时机、参数、能否重载
- 用 static 成员统计对象个数,说明类外为什么还要定义一次
- 解释 this 指针指向谁,说明静态成员函数为什么不能用 this
- 把本日 31 道客观题做完,错题标记出来
继承、多态与虚函数
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 9 道客观题(单选 9 / 判断 0,其中 0 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2024-03 | 1 |
| 2024-06 | 2 |
| 2025-03 | 1 |
| 2025-06 | 1 |
| 2025-12 | 1 |
| 2026-03 | 1 |
| 2026-09 | 2 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.4 深度/广度优先搜索。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
继承与多态是六级最难、也最容易被扣分的一块。真题的典型问法是「这段代码输出什么」——考的就是**虚函数到底绑定了谁**。一句话记住:**没有 virtual 就是编译期按指针类型定,有 virtual 才是运行期按对象类型定**。
②知识地图 · 本考点思维导图
- 继承
- 语法:class Derived : public Base
- 派生类拥有基类的成员(private 除外)
- 构造顺序:先基类、再成员、最后自己
- 析构顺序:与自己相反
- 三种继承方式 public / protected / private
- 访问权限在继承中的变化
- public 继承:public→public,protected→protected,private 不可见
- protected 继承:public/protected → protected
- private 继承:public/protected → private
- 函数重写(override)
- 派生类定义与基类**同名同参**的函数
- 基类函数是 virtual → 重写(多态)
- 基类函数不是 virtual → 隐藏(按指针类型走)
- 多态
- 静态绑定(编译期):普通函数、重载
- 动态绑定(运行期):虚函数
- 三条件:继承 + 虚函数重写 + 基类指针/引用调用
- 结果:调哪个函数看**对象的真实类型**
- 虚函数
- virtual void speak();
- 通过虚函数表(vtable)实现
- 构造函数不能是虚函数;析构函数**应该是**虚函数
- 纯虚函数与抽象类
- virtual void f() = 0;
- 含纯虚函数的类是抽象类,不能实例化
- 派生类必须实现所有纯虚函数才能实例化
- 常见陷阱
- 基类指针 delete 派生类对象 → 基类析构必须 virtual
- 构造/析构函数里调用虚函数 → 不产生多态
- 静态成员函数不能是 virtual
③核心精讲
1. 继承的基本写法
class Animal {
public:
void eat() { cout << "eating "; }
};
class Cat : public Animal { // Cat 公开继承 Animal
public:
void meow() { cout << "meow "; }
};
Cat c;
c.eat(); // ✅ 继承来的
c.meow(); // ✅ 自己的
构造与析构的顺序:
class Base { public: Base() { cout << "B+ "; } ~Base() { cout << "B- "; } };
class Der : public Base
{ public: Der() { cout << "D+ "; } ~Der() { cout << "D- "; } };
Der d; // 输出:B+ D+ (先构造基类)
// 离开作用域:D- B- (先析构自己)
口诀:构造由内向外(基类→派生),析构由外向内(派生→基类)。
2. 三种继承方式对权限的影响
| 基类成员 | public 继承 | protected 继承 | private 继承 |
|---|---|---|---|
| public | public | protected | private |
| protected | protected | protected | private |
| private | 不可见 | 不可见 | 不可见 |
private 成员在任何继承方式下派生类都访问不到,只能通过基类的 public/protected 接口。 想让派生类能访问又不想让外部访问,用 protected。
3. 多态:这一节是全章核心
class Animal {
public:
virtual void speak() { cout << "Animal "; } // 有 virtual
};
class Cat : public Animal {
public:
void speak() override { cout << "Cat "; } // 重写
};
Animal *p1 = new Animal();
Animal *p2 = new Cat(); // 基类指针指向派生类对象
p1->speak(); // Animal
p2->speak(); // Cat ← 关键:看对象的真实类型,不看指针类型
把 virtual 去掉再试:
class Animal {
public:
void speak() { cout << "Animal "; } // 没有 virtual
};
...
Animal *p2 = new Cat();
p2->speak(); // Animal ← 按指针类型(Animal*)定,编译期就绑好了
| 有 virtual | 没有 virtual | |
|---|---|---|
| 绑定时机 | 运行期(动态绑定) | 编译期(静态绑定) |
| 依据 | 对象的真实类型 | 指针/引用的声明类型 |
| 名称 | 重写(override) | 隐藏(hiding) |
多态成立的三个条件(缺一不可):
- 有继承关系;
- 基类函数声明为
virtual,派生类同名同参重写; - 通过基类指针或引用调用。
第 3 条最容易漏:直接写
Cat c; c.speak();一定是调用 Cat 的版本, 跟 virtual 无关——因为编译期就知道c是 Cat。
4. 虚析构:为什么必须有
class Base { public: ~Base() { cout << "B- "; } }; // 非虚析构
class Der : public Base { public: ~Der() { cout << "D- "; } };
Base *p = new Der();
delete p; // 只输出 B- ← Der 的析构没被调用,内存泄漏!
改成 virtual ~Base() 后,delete p 会先调 Der::~Der() 再调 Base::~Base()。
规则:只要一个类可能被继承,并且可能通过基类指针删除对象,析构函数就必须是 virtual。
5. 纯虚函数与抽象类
class Shape {
public:
virtual double area() const = 0; // 纯虚函数
};
// Shape s; // ❌ 抽象类不能实例化
class Circle : public Shape {
double r;
public:
Circle(double r) : r(r) {}
double area() const override { return 3.14159 * r * r; }
};
Circle c(2); // ✅ 实现了所有纯虚函数,可以实例化
抽象类的作用:定义接口规范,强制所有子类实现它。
6. 五个高频陷阱
| 陷阱 | 说明 |
|---|---|
| 构造函数不能是 virtual | 对象还没造出来,谈不上动态绑定 |
| 析构函数应该是 virtual | 否则基类指针 delete 派生对象会漏析构 |
| 构造/析构函数里调虚函数不产生多态 | 此时对象类型还没「完整」 |
| static 函数不能是 virtual | 静态成员没有 this,无法按对象绑定 |
| 重载 ≠ 重写 | 重载是同名不同参(编译期),重写是同名同参(运行期) |
class Shape {
protected:
string name;
public:
Shape(const string& n) : name(n) {}
virtual double area() const {
return 0.0;
}
};
class Circle : public Shape {
private:
double radius; // 半径
public:
Circle(const string& n, double r) : Shape(n), radius(r) {}
double area() const override {
return 3.14159 * radius * radius;
}
};
class Rectangle : public Shape {
private:
double width; // 宽度
double height; // 高度
public:
Rectangle(const string& n, double w, double h) : Shape(n), width(w), height(h)
{}
double area() const override {
return width * height;
}
};
int main() {
Circle circle("MyCircle", 5.0);
Rectangle rectangle("MyRectangle", 4.0, 6.0);
Shape* shapePtr = &circle;
cout << "Area: " << shapePtr->area() << endl;
shapePtr = &rectangle;
cout << "Area: " << shapePtr->area() << endl;
return 0;
}#include <iostream>
using namespace std;
class shape {
protected:
int width, height;
public:
shape(int a = 0, int b = 0) {
width = a;
height = b;
}
virtual int area() {
cout << "parent class area: " <<endl;
return 0;
}
};
class rectangle: public shape {
public:
rectangle(int a = 0, int b = 0) : shape(a, b) { }
int area () {
cout << "rectangle area: ";
return (width * height);
}
};
class triangle: public shape {
public:
triangle(int a = 0, int b = 0) : shape(a, b) { }
int area () {
cout << "triangle area: ";
return (width * height / 2);
}
};
int main() {
shape *pshape;
rectangle rec(10, 7);
triangle tri(10, 5);
pshape = &rec;
pshape->area();
pshape = &tri;
pshape->area();
return 0;
}class Shape {
public:
virtual void draw() {
cout << "绘制图形" << endl;
}
virtual ~Shape() {}
};
class Circle : public Shape {
public:
void draw() override {
cout << "绘制圆形" << endl;
}
};
class Rectangle : public Shape {
public:
void draw() override {
cout << "绘制矩形" << endl;
}
};
int main() {
Shape* s1 = new Circle();
Shape* s2 = new Rectangle();
s1->draw();
s2->draw();
delete s1;
delete s2;
return 0;
}class Animal {
public:
virtual void speak() {
cout << "Animal ";
}
virtual ~Animal() = default;
};
class Cat : public Animal {
public:
void speak() override {
cout << "Cat ";
}
};
int main() {
Animal *p = new Cat();
p->speak();
delete p;
return 0;
}class Base {
public:
Base() {
cout << "B ";
}
virtual ~Base() {
cout << "~B ";
}
};
class Derived : public Base {
public:
Derived() {
cout << "D ";
}
~Derived() {
cout << "~D ";
}
};
int main() {
Base *p = new Derived();
delete p;
return 0;
}- 1.A 关于下面代码,说法错误的是( )。…
- 2.D 面向对象的编程思想主要包括以下哪些原则( )?…
- 3.D 面向对象的编程思想主要包括( )原则。…
- 4.A 运行下列代码,屏幕上输出( )。…
- 5.D 下列哪一项不是面向对象编程的基本特征?…
- 6.C 在面向对象编程中,下列关于 虚函数 的描述中,错误的是( )。…
- 7.B 下列代码中,s1->draw(); 和 s2->draw(); 输出…
- 8.B 下列代码执行后的输出结果是( )。…
- 9.C 下列代码执行后的输出顺序是( )。…
④今日打卡 · 点一下就能勾选
- 写出 Base/Der 的构造与析构顺序,说明为什么是这个顺序
- 列表说明 public/protected/private 三种继承对基类成员的影响
- 写一段代码证明「有 virtual 调派生、无 virtual 调基类」
- 背出多态成立的三个条件,说明第 3 条为什么不能漏
- 说明虚析构的必要性,给一个内存泄漏的例子
- 写出一个抽象类与实现它的子类,指出哪一行不能实例化
- 把本日 9 道客观题做完,错题标记出来
图与搜索(DFS / BFS)
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 14 道客观题(单选 14 / 判断 0,其中 4 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023-09 | 1 |
| 2024-03 | 1 |
| 2024-06 | 3 |
| 2024-12 | 3 |
| 2025-03 | 2 |
| 2025-06 | 1 |
| 2025-09 | 1 |
| 2025-12 | 1 |
| 2026-03 | 1 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.5 简单动态规划与背包。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
六级把图从「听说过」变成「会存会搜」。考点集中在三处:**邻接矩阵 vs 邻接表的复杂度差异**、**DFS 与 BFS 的区别**、**BFS 求无权图最短路**。所有搜索题都先问自己两个问题:图是有向还是无向?要判重吗(visited 数组)?
②知识地图 · 本考点思维导图
- 图的基本概念
- 顶点 V、边 E
- 有向图 / 无向图
- 度:无向图的度、有向图的入度与出度
- 连通图 / 强连通图
- 完全图:n 个点有 n(n−1)/2 条边(无向)
- 树是 n−1 条边的连通无环图
- 两种存储方式
- 邻接矩阵 g[i][j]
- 空间 O(n²),判断两点是否相邻 O(1)
- 适合稠密图
- 邻接表 vector<int> g[i]
- 空间 O(n+m),遍历某点的邻居快
- 适合稀疏图
- 深度优先搜索 DFS
- 一条路走到黑,走不通再回退
- 递归实现 / 显式栈
- 复杂度 O(n+m)
- 用途:连通块、路径存在性、拓扑排序
- 广度优先搜索 BFS
- 一层一层往外扩
- 队列实现
- 复杂度 O(n+m)
- 用途:**无权图最短路**、层次遍历
- 判重:visited 数组
- DFS / BFS 都必须判重
- 否则会重复访问、甚至死循环
- 进阶(了解)
- 拓扑排序:入度为 0 依次入队
- 并查集:连通块合并
- LCA:最近公共祖先
③核心精讲
1. 邻接矩阵 vs 邻接表
// ① 邻接矩阵:n 个点用 n×n 的数组
int g[1005][1005]; // g[i][j] = 1 表示 i 到 j 有边
g[u][v] = 1; // 无向图还要 g[v][u] = 1
// ② 邻接表:每个点存一个邻居列表
vector<int> g[1005];
g[u].push_back(v);
g[v].push_back(u); // 无向图要加两次
| 邻接矩阵 | 邻接表 | |
|---|---|---|
| 空间 | O(n²) | O(n + m) |
| 判断 u、v 是否相邻 | O(1) | O(度数) |
| 枚举 u 的所有邻居 | O(n) | O(度数) |
| 适合 | 稠密图 | 稀疏图 |
n = 1000 时矩阵要 10⁶ 个 int(约 4 MB),n = 10⁵ 就存不下了——这是选择题常考点。
2. DFS:一条路走到黑
vector<int> g[N];
bool vis[N];
void dfs(int u) {
vis[u] = true; // ① 先标记
cout << u << " ";
for (int v : g[u]) {
if (!vis[v]) dfs(v); // ② 没访问过就进去
}
}
// 调用:dfs(start);
递归版的三步:标记 → 处理 → 对每个未访问的邻居递归。 必须判重,否则有环的图会无限递归。
3. BFS:一层一层扩
int bfs(int s, int t) { // 返回 s 到 t 的最短边数
vector<int> dist(N, -1);
queue<int> q;
dist[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front(); q.pop();
if (u == t) return dist[u];
for (int v : g[u]) {
if (dist[v] == -1) { // 没访问过
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
return -1; // 不可达
}
为什么 BFS 能求最短路:队列保证按「离起点的距离」从小到大出队, 第一次访问到某个点时,走的一定是最少步数。
注意:这个结论只对无权图(或边权全相等)成立。 有边权的最短路要用 Dijkstra 等算法,那是七级内容。
4. DFS 与 BFS 对比
| DFS | BFS | |
|---|---|---|
| 数据结构 | 栈(递归) | 队列 |
| 扩展方式 | 一条路走到底 | 一层一层 |
| 能否求最短路 | ❌ 不能保证 | ✅ 无权图可以 |
| 空间 | O(深度) | O(宽度) |
| 典型用途 | 连通块、全排列、拓扑排序 | 最短路、层次遍历 |
| 复杂度 | 都是 O(n + m) | 都是 O(n + m) |
5. 判重的两种写法
// 写法一:进队/进递归时标记(推荐)
vis[u] = true;
for (v : g[u]) if (!vis[v]) { vis[v] = true; q.push(v); }
// 写法二:出队时标记(容易重复入队,一般不用)
推荐写法一:在「准备访问」时就标记,能保证每个点最多进队列一次。
6. 常见错误清单
| 错误 | 后果 |
|---|---|
| 无向图只加了一条边 | 只能单向走 |
忘了 vis 判重 | 死循环 / 重复计数 |
vis 没在每组数据前清空 | 第二组数据全错 |
| BFS 用栈、DFS 用队列 | 逻辑没错但性质全变了(BFS 不再保证最短路) |
| 从 0 开始编号却按 1 初始化 | 下标错位 |
void bfs(TreeNode* root) {
if (root == NULL) {
return;
}
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* current = q.front();
q.pop();
cout << current->val << " ";
if (current->left) {
q.push(current->left);
}
if (current->right) {
q.push(current->right);
}
}
}
1
/ \
2 3
/ \ \
8 9 6
/ \ \
4 5 7
/ \
10 11#include <iostream>
#include <queue>
using namespace std;
// 二叉树节点的定义
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 宽度优先搜索(BFS)迭代实现
TreeNode* bfs(TreeNode* root, int a) {
if (root == nullptr) return nullptr;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
if (node->val == a)
return node;
cout << node->val << " "; // 先访问当前节点
if (node->left) q.push(node->left); // 将左子节点入队
if (node->right) q.push(node->right); // 将右子节点入队
}
return nullptr;
}#include <iostream>
#include <stack>
using namespace std;
// 非递归深度优先搜索(DFS)
TreeNode* dfs(TreeNode* root, int a) {
if (root == nullptr) return nullptr;
stack<TreeNode*> stk;
stk.push(root);
while (!stk.empty()) {
TreeNode* node = stk.top();
stk.pop();
if (node->val == a)
return node;
cout << node->val << " "; // 访问当前节点
if (node->right) stk.push(node->right); // 先压入右子节点
if (node->left) stk.push(node->left); // 再压入左子节点
}
return nullptr;
}void dfs(TreeNode* root) {
if (root == nullptr)
return;
stack<TreeNode*> s;
s.push(root);
while (!s.empty()) {
———————————————————————— // 在此处填入代码
cout << node->value << " ";
if (node->right) s.push(node->right);
if (node->left) s.push(node->left);
}
}#include <queue>
void bfs(TreeNode* root) {
if (root == NULL) return;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
———————————————————————— // 在此处填入代码
cout << node->val << " ";
if (node->left) {
q.push(node->left);
}
if (node->right) {
q.push(node->right);
}
}
}TreeNode* findNode(TreeNode* root, int target) {
if (root == nullptr) return nullptr;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* current = q.front();
q.pop();
if (current->val == target) {
return current; // 找到目标节点
}
———————————————————————— // 在此处填入代码
}
return nullptr; // 未找到目标节点
}
if (current->left) q.push(current->left);
if (current->right) q.push(current->right);
if (current->left) q.pop(current->left);
if (current->right) q.pop(current->right);
if (current->left) q.front(current->left);
if (current->right) q.front(current->right);
if (current->left) q.push(current->right);
if (current->right) q.push(current->left);int countLeafNodes(TreeNode* root) {
if (root == nullptr) return 0;
stack<TreeNode*> s;
s.push(root);
int count = 0;
while (!s.empty()) {
TreeNode* node = s.top();
s.pop();
if (node->left == nullptr && node->right == nullptr) {
count++;
}
if (node->right) s.push(node->right);
———————————————————————— // 在此处填入代码
}
return count;
}struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
void dfs(TreeNode* root, vector<int>& result) {
if (root == nullptr) return;
__________________________
}
result.push_back(root->val);
dfs(root->left);
dfs(root->right);
result.push_back(root->left->val);
dfs(root->right);
dfs(root->left);
result.push_back(root->left->val);
dfs(root->left);
dfs(root->right);
result.push_back(root->right->val);
dfs(root->right);
dfs(root->left);void bfs(TreeNode* root) {
if (!root) return;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
cout << node->val << " ";
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
}- 1.C 阅读以下广度优先搜索的代码: 使用以上算法遍历以下这棵树,可能的输出…
- 2.C 阅读以下二叉树的广度优先搜索代码: 时,可能的输出是( )。 使用以…
- 3.A 同上题中的二叉树,阅读以下二叉树的深度优先搜索代码: 时,可能的输出…
- 4.C 在上题的树中搜索数值时,采用深度优先搜索一共比较的节点数为( )。…
- 5.B 阅读以下二叉树的深度优先搜索算法,横线上应填写( )。…
- 6.D 阅读以下二叉树的广度优先搜索的代码,横线上应填写( )。…
- 7.A 以下代码实现了二叉树的广度优先搜索(BFS),并查找特定值的节点,则…
- 8.A 以下代码实现了二叉树的深度优先搜索(DFS),并统计叶子结点的数量,…
- 9.A 请将下列 C++ 实现的深度优先搜索(DFS)代码补充完整,横线处应…
- 10.A 令 是树的节点数目,下列代码实现了树的广度优先遍历,其时间复杂度是(…
N == front ,出队对应的操作为:front = (front + 1) % N ,入队对于的操作为:rear = (rear + 1) % N 。循环队列长度 N = 6 ,初始 front = 1 , rear = 1 ,执行操作序列为:入队, 入队, 入队, 出队, 入队, 入队,
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
vector<int> rightSideView(TreeNode* root) {
unordered_map<int, int> rightmostValueAtDepth;
int max_depth = -1;
queue<TreeNode*> nodeQueue;
queue<int> depthQueue;
nodeQueue.push(root);
depthQueue.push(0);
while (!nodeQueue.empty()) {
TreeNode* node = nodeQueue.front(); nodeQueue.pop();
int depth = depthQueue.front(); depthQueue.pop();
if (node != NULL) {
max_depth = max(max_depth, depth);
rightmostValueAtDepth[depth] = node->val;
nodeQueue.push(node->left);
nodeQueue.push(node->right);
depthQueue.push(________);
depthQueue.push(________);
}
}
vector<int> rightView;
for (int depth = 0; ________; ++depth) {
rightView.push_back(rightmostValueAtDepth[depth]);
}
return rightView;
};
depth
depth
depth < max_depth
depth + 1
depth + 1
depth <= max_depth
depth + 1
depth + 1
depth < max_depth
depth
depth
depth <= max_depth- 11.B 个节点的双向循环链,在其中查找某个节点的平均时间复杂度是( )。…
- 12.B 个节点的双向循环链,在其中查找某个节点的平均时间复杂度是( )。…
- 13.B 假设循环队列数组长度为 N ,其中队空判断条件为:front == …
- 14.B 给定一棵二叉树,采用广度优先搜索 (BFS) 算法,返回右视图所有节…
④今日打卡 · 点一下就能勾选
- 写出邻接矩阵与邻接表两种建图代码,比较空间复杂度
- 写出 DFS 的递归模板,标出为什么必须判重
- 写出 BFS 求最短路的代码,说明为什么第一次到达就是最短
- 列表对比 DFS 与 BFS 的数据结构、空间、能否求最短路
- 说明「BFS 能求最短路」的前提条件是什么
- 列出建图与搜索的 5 个常见错误
- 把本日 14 道客观题做完,错题标记出来
动态规划初步
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 24 道客观题(单选 24 / 判断 0,其中 5 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023-09 | 1 |
| 2023-12 | 1 |
| 2024-03 | 2 |
| 2024-06 | 2 |
| 2024-09 | 2 |
| 2024-12 | 2 |
| 2025-03 | 2 |
| 2025-06 | 3 |
| 2025-09 | 2 |
| 2025-12 | 2 |
| 2026-03 | 2 |
| 2026-09 | 3 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.6 面向对象与类的创建。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
动态规划是六级的新增重点,也是学生最容易「听懂但写不出」的一块。真题的考法主要是**给一段 DP 代码,问 dp 数组的某个值**。所以先别急着写,先练**填表**:把 dp 数组一行行填出来。0/1 背包的**容量倒序**是必考点,一定要能解释清楚为什么。
②知识地图 · 本考点思维导图
- DP 与递归的区别
- 递归:自顶向下,有大量重复计算
- 记忆化:递归 + 缓存,仍有递归栈开销
- DP:自底向上填表,无重复计算
- DP 四步法
- ① 定状态:dp[i] 表示什么
- ② 写转移:dp[i] 从哪些更小的状态来
- ③ 定边界:dp[0]、dp[1] 是多少
- ④ 定答案:要的是 dp[n] 还是 max(dp[1..n])
- 线性 DP 经典题
- 爬楼梯:dp[i] = dp[i−1] + dp[i−2]
- 最大子段和:dp[i] = max(a[i], dp[i−1] + a[i])
- 最长上升子序列 LIS:O(n²) 或 O(n log n)
- 数字三角形:dp[i][j] = max(上、左上) + a[i][j]
- 背包问题
- 0/1 背包:每件物品**只能取一次**
- 二维:dp[i][j] = max(dp[i−1][j], dp[i−1][j−w]+v)
- 一维:容量**倒序**遍历
- 完全背包:每件物品**可以取无限次**
- 一维:容量**正序**遍历
- 为什么倒序/正序是分水岭
- 倒序 → 用到的是「上一轮」的值 → 每件只用一次
- 正序 → 用到的是「本轮」刚更新的值 → 可重复使用
- 复杂度
- 时间 O(n × 容量)
- 空间可滚动优化到 O(容量)
③核心精讲
1. 从递归到 DP:以爬楼梯为例
每次可以走 1 阶或 2 阶,问走到第 n 阶有几种走法。
朴素递归(会超时):
int f(int n) {
if (n <= 2) return n;
return f(n - 1) + f(n - 2); // 大量重复计算,O(2ⁿ)
}
DP 填表(O(n)):
int dp[100];
dp[1] = 1; // ① 边界
dp[2] = 2;
for (int i = 3; i <= n; i++)
dp[i] = dp[i - 1] + dp[i - 2]; // ② 转移
cout << dp[n]; // ③ 答案
n = 6 时填表:
| i | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|
| dp[i] | 1 | 2 | 3 | 5 | 8 | 13 |
对比:递归是「要答案 → 往回问」,DP 是「从最小的答案一路推出来」。 两者结果一样,但 DP 每个状态只算一次。
2. DP 四步法(写任何 DP 题都按这四步)
| 步骤 | 要问自己的问题 |
|---|---|
| ① 定状态 | dp[i] 或 dp[i][j] 表示什么?一句话说清 |
| ② 写转移 | dp[i] 从哪些更小的状态来?怎么算出来 |
| ③ 定边界 | 最小的那些状态(dp[0]、dp[1])是多少 |
| ④ 定答案 | 题目要的是 dp[n] 还是 max(dp[1..n]) |
3. 最大子段和(线性 DP 典型)
int dp[N], ans = a[1];
dp[1] = a[1];
for (int i = 2; i <= n; i++) {
dp[i] = max(a[i], dp[i - 1] + a[i]); // 接上前面,还是从自己重新开始
ans = max(ans, dp[i]);
}
- 状态:
dp[i]= 以a[i]结尾的最大子段和; - 转移:要么接上前面(
dp[i-1] + a[i]),要么另起炉灶(a[i]); - 答案:
max(dp[1..n])(不是dp[n],这是最常见的错)。
4. 0/1 背包:二维版
有 n 件物品,第 i 件重 w[i]、价值 v[i],背包容量 C,每件最多取一次,求最大价值。
int dp[N][C + 1];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= C; j++) {
dp[i][j] = dp[i - 1][j]; // 不取第 i 件
if (j >= w[i])
dp[i][j] = max(dp[i][j],
dp[i - 1][j - w[i]] + v[i]); // 取第 i 件
}
}
cout << dp[n][C];
- 状态:
dp[i][j]= 前 i 件物品、容量 j 时的最大价值; - 转移:不取(
dp[i-1][j])或取(dp[i-1][j-w[i]] + v[i]); - 注意取的时候用的是
dp[i-1](上一行),因为第 i 件只能用一次。
5. 一维优化:为什么 0/1 背包要倒序
把二维压成一维:
int dp[C + 1] = {0};
for (int i = 1; i <= n; i++)
for (int j = C; j >= w[i]; j--) // ← 倒序!
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
为什么必须倒序:
dp[j - w[i]] 如果 j 正序遍历,这个位置可能在本轮已经被更新过了(也就是已经取过第 i 件), 再用它就会把第 i 件取两次,退化成完全背包。 倒序遍历时,dp[j - w[i]] 一定还是上一轮的值,保证每件只用一次。
| 背包类型 | 容量遍历顺序 | 含义 |
|---|---|---|
| 0/1 背包 | 倒序 j = C → w[i] | 每件最多一次 |
| 完全背包 | 正序 j = w[i] → C | 每件可以无限次 |
这一处「倒序/正序」的区别是六级最经典的考点,选择题和阅读程序都会考。
6. 完全背包对比
// 完全背包:只把内层循环方向反过来
for (int i = 1; i <= n; i++)
for (int j = w[i]; j <= C; j++) // 正序
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
7. 手推一张 DP 表(考试必用)
物品:w = {2, 3, 4},v = {3, 4, 5},容量 C = 5,0/1 背包。
| i\j | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 (w2,v3) | 0 | 0 | 3 | 3 | 3 | 3 |
| 2 (w3,v4) | 0 | 0 | 3 | 4 | 4 | 7 |
| 3 (w4,v5) | 0 | 0 | 3 | 4 | 5 | 7 |
答案 dp[3][5] = 7(取物品 1 和 2:重量 2+3=5,价值 3+4=7)。
遇到 DP 阅读程序题,就照这张表一行行填,比在脑子里推可靠得多。
for each item (w, v):
for (int j = W; j >= w; --j)
dp[j] = max(dp[j], dp[j-w] + v);#include <iostream>
#include <vector>
using namespace std;
// 0/1背包问题
int knapsack(int W, const vector<int>& weights, const vector<int>& values, int n) {
vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int w = 0; w <= W; ++w) {
if (weights[i - 1] <= w) {
dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] +
values[i - 1]);
}
else
{
dp[i][w] = dp[i - 1][w];
}
}
}
return dp[n][W];
}int knapsack(int W, vector<int>& weights, vector<int>& values) {
int n = weights.size();
vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= W; j++) {
if (weights[i-1] > j) {
dp[i][j] = dp[i-1][j]; // 当前物品装不下
} else {
dp[i][j] = max(_________________________); // 在此处填入代码
}
}
}
return dp[n][W];
}int knapsack(int W, vector<int>& wt, vector<int>& val, int n) {
vector<int> dp(W+1, 0);
for (int i = 0; i < n; ++i) {
for (int w = W; w >= wt[i]; --w) {
________________________ // 在此处填写代码
}
}
return dp[W];
}for (int i = 0; i < n; ++i) {
for (int w = W; w >= weight[i]; --w) {
dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
}
}int knapsack1D(int W, vector<int>& wt, vector<int>& val, int n) {
vector<int> dp(W+1, 0);
for (int i = 0; i < n; ++i) {
for (int w = W; w >= wt[i]; --w) {
dp[w] = max(dp[w], dp[w - wt[i]] + val[i]);
}
}
return dp[W];
}dp[i] = dp[i - 1] + dp[i - 2] ,下面关于 dp[i] 的含义最合适的是( )。
int function(vector<int>& nums) {
int n = nums.size();
if (n == 0)
return 0;
if (n == 1)
return nums[0];
vector<int> dp(n, 0);
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < n; ++i) {
dp[i] = max(dp[i - 1], nums[i] + dp[i - 2]);
}
return dp[n - 1];
}int visit(vector<int>& nums) {
if (nums.empty()) {
return 0;
}
int size = nums.size();
if (size == 1) {
return nums[0];
}
vector<int> dp = vector<int>(size, 0);
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < size; i++) {
dp[i] = ______; // 在此处填写代码
}
return dp[size - 1];
}int maxSum(vector<int> &a) {
int n = a.size();
if (n == 0)
return 0;
if (n == 1)
return a[0];
vector<int> dp(n);
dp[0] = a[0];
dp[1] = max(a[0], a[1]);
for (int i = 2; i < n; ++i)
dp[i] = __________________________;
return dp[n - 1];
}- 1.B 0/1 背包(每件物品最多选一次)问题通常可用一维动态规划求解,核心…
- 2.C 阅读以下用动态规划解决的0-1背包问题的函数,假设背包的容量是10k…
- 3.B 以下代码实现了0/1背包问题的动态规划解法。假设物品重量为weigh…
- 4.D 给定个物品和一个最大承重为 的背包,每个物品有一个重量和价值,每个物…
- 5.A 下面是一维数组实现的 0/1 背包。内层循环必须从大到小枚举容量,主…
- 6.C 给定个物品和一个最大承重为 的背包,每个物品有一个重量和价值,每个物…
- 7.A 元宵节晚上,小朋友沿着一条发光石板路前进,每次可向前走 1 块或 2…
- 8.C 以下动态规划算法的含义与目的是( )。…
- 9.C 小朋友们去邻里拜年,每个家里有不同数量的糖果。规则是:不能连续进入两…
- 10.C 下面代码求从包含非负元素的数组中选择若干个互不相邻元素所能得到的最大…
int jump_recur(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
return jump_recur(n - 1) + jump_recur(n - 2);
}
int jump_dp(int n) {
vector<int> dp(n + 1); // 创建一个动态规划数组,用于保存已计算的值
// 初始化前两个数
dp[1] = 1;
dp[2] = 2;
// 从第三个数开始计算斐波那契数列
for (int i = 3; i <= n; ++i) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}int ways(int n) {
if (n <= 2)
return n;
vector<int> dp(n + 1);
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; ++i)
dp[i] = __________________________;
return dp[n];
}- 11.C 青蛙每次能跳1或2步。下面是青蛙跳到第N 步台阶C++实现代码。该段…
- 12.B 动态规划通常用于解决( )。…
- 13.B 以下关于动态规划的描述,( )是正确的。…
- 14.C 假设背包的最大容量,共有有个物品可供选择,4个物品的重量分别为 ,对…
- 15.B 以下关于动态规划算法特性的描述,正确的是( )。…
- 16.D 青蛙每次能跳1或2步,下面代码计算青蛙跳到第n步台阶有多少种不同跳法…
- 17.B 下面代码计算走到第 n 级台阶的方法数,每次可以走 1 级或 2 级…
- 18.D 下面的 fiboA() 和 fiboB() 两个函数分别实现斐波那契…
- 19.B 关于动态规划的描述,正确的是( )。…
- 20.B 在一个循环队列中,front 是指向队头的指针, rear 指向队尾…
- 21.A 循环队列常用于实现数据缓冲。假设一个循环队列容量为 5 (即最多存放…
- 22.B 以下关于动态规划的说法中,错误的是( )。…
- 23.A 在求解最优化问题时,动态规划常常涉及到两个重要性质,即最优子结构和(…
- 24.A 在求解最优化问题时,动态规划常常涉及到两个重要性质,即最优子结构和(…
④今日打卡 · 点一下就能勾选
- 用爬楼梯对比朴素递归与 DP 填表,说明重复计算在哪
- 背出 DP 四步法,用它分析最大子段和
- 写出最大子段和,指出答案为什么是 max(dp) 而不是 dp[n]
- 写出 0/1 背包的二维转移方程,说明取的时候为什么用 dp[i−1]
- 解释 0/1 背包一维优化为什么必须倒序,正序会变成什么
- 手推 w={2,3,4}、v={3,4,5}、C=5 的完整 DP 表
- 把本日 24 道客观题做完,错题标记出来
指针、内存与算法综合
①今日考情 · 真题分布与备考建议
本考点在 GESP C++ 6级近 14 期真题中共 20 道客观题(单选 20 / 判断 0,其中 3 道需看原卷配图)。本页把这一考点的真题全部收进来了,一道没漏,按每 10 题一张卡分组,可分次完成。
本期分布
| 期次 | 题数 |
|---|---|
| 2023-09 | 2 |
| 2023-12 | 3 |
| 2024-03 | 4 |
| 2024-06 | 2 |
| 2024-12 | 1 |
| 2025-06 | 3 |
| 2025-09 | 2 |
| 2025-12 | 2 |
| 2026-03 | 1 |
配套教材
GESP 大通关 6 级(全书 76 页):本天对应 6.6 栈、队列与循环队列(综合)。教材按同一套大纲顺序编排,可对照阅读。
备考建议(出题人视角)
最后一天收口:把指针内存、复杂度、算法选择这些「散点」串起来。六级考指针比五级更狠——**深浅拷贝、对象里的指针成员、虚析构**。复杂度的考法和五级一样,但会多一层递归复杂度(如归并排序的 O(n log n) 怎么来的)。
②知识地图 · 本考点思维导图
- 指针与引用
- 指针可以为空、可以改指向
- 引用必须初始化、不能改绑
- 引用更安全,指针更灵活
- 对象中的指针成员
- 有 new 就必须在析构里 delete
- 浅拷贝:只复制指针值 → 两个对象指向同一块内存
- 深拷贝:重新 new 一块并复制内容
- 深浅拷贝的后果
- 浅拷贝 + 两次析构 → 重复 delete 崩溃
- 深拷贝 → 各自独立
- 内存管理的四条铁律
- new 与 delete 配对
- new[] 与 delete[] 配对
- delete 后置空指针
- 谁申请谁释放
- 递归复杂度分析
- 单分支递归 → O(n)
- 朴素双分支 → O(2ⁿ)
- 归并排序 → O(n log n)
- log n 层 × 每层合并 O(n)
- 二分 → O(log n)
- 主定理速记(够用版)
- T(n)=T(n/2)+O(1) → O(log n)
- T(n)=T(n/2)+O(n) → O(n)
- T(n)=2T(n/2)+O(n) → O(n log n)
- 算法选择
- 数据有序 → 二分
- 求最短路(无权)→ BFS
- 求方案数 / 最值 → DP
- 求全部方案 → DFS 回溯
- 局部最优能证明 → 贪心
③核心精讲
1. 指针 vs 引用
指针 int *p | 引用 int &r | |
|---|---|---|
| 能否为空 | ✅ 可以 nullptr | ❌ 必须绑定对象 |
| 能否改指向 | ✅ 可以 | ❌ 一旦绑定不可改 |
| 是否占内存 | 占(存地址) | 通常不额外占 |
| 用起来 | 要解引用 *p | 像普通变量 |
| 安全性 | 容易出错 | 更安全 |
2. 对象里有指针成员:深浅拷贝
class Buffer {
int *data;
public:
Buffer(int n) { data = new int[n]; }
~Buffer() { delete[] data; }
};
Buffer a(10);
Buffer b = a; // ⚠️ 编译器生成的默认拷贝:只复制指针值(浅拷贝)
// a.data 和 b.data 指向同一块内存
// 出了作用域,a 和 b 各析构一次 → 同一块内存被 delete 两次 → 崩溃
浅拷贝:只复制指针本身(地址),两个对象共享同一块内存。 深拷贝:重新 new 一块,把内容复制过去。
class Buffer {
int *data;
int n;
public:
Buffer(int n) : n(n), data(new int[n]) {}
Buffer(const Buffer &o) : n(o.n), data(new int[o.n]) { // 深拷贝
for (int i = 0; i < n; i++) data[i] = o.data[i];
}
~Buffer() { delete[] data; }
};
3. 内存管理四条铁律
| 铁律 | 违反的后果 |
|---|---|
new 必须配 delete | 内存泄漏 |
new[] 必须配 delete[] | 未定义行为 |
delete 之后把指针置 nullptr | 悬空指针,再次使用会崩 |
| 谁申请谁释放 | 责任不清,早晚泄漏或重复释放 |
4. 递归复杂度:归并排序为什么是 O(n log n)
void mergeSort(int l, int r) {
if (l >= r) return;
int mid = (l + r) / 2;
mergeSort(l, mid);
mergeSort(mid + 1, r);
merge(l, mid, r); // 合并:O(n)
}
- 递归层数:每次长度减半 →
log₂n层; - 每层合并的总工作量:所有块加起来还是要处理 n 个元素 →
O(n); - 相乘:
O(n log n)。
画成树更直观(以 n=8 为例):
[8] ← 每层合并总量 8
[4] [4]
[2] [2] [2] [2]
[1][1][1][1][1][1][1][1] ← 共 log₂8 = 3 层
3 层 × 每层 8 次 = 24 次比较 ≈ n log n。
5. 主定理速记表
| 递推式 | 复杂度 | 典型算法 |
|---|---|---|
T(n) = T(n/2) + O(1) | O(log n) | 二分查找 |
T(n) = T(n/2) + O(n) | O(n) | 快速选择(平均) |
T(n) = 2T(n/2) + O(n) | O(n log n) | 归并排序、快排(平均) |
T(n) = T(n-1) + O(1) | O(n) | 线性递归(阶乘、求和) |
T(n) = 2T(n-1) + O(1) | O(2ⁿ) | 汉诺塔、朴素斐波那契 |
T(n) = T(n-1) + O(n) | O(n²) | 冒泡、插入排序 |
6. 算法选择决策表
| 题目特征 | 首选算法 |
|---|---|
| 数组有序,找一个值 / 找边界 | 二分查找 |
| 求「最小的最大值」「最大的最小值」 | 二分答案 |
| 无权图最短步数 | BFS |
| 求方案数、最优值,且有重叠子问题 | 动态规划 |
| 要枚举所有方案(排列、组合、棋盘) | DFS 回溯 |
| 每步局部最优能证明全局最优 | 贪心 |
| 判断连通性、合并集合 | 并查集 |
| 只需判断可达性 | DFS 或 BFS |
7. 读程序的最终检查清单
| 检查 | 说明 |
|---|---|
| 数组越界 | 循环上界是 < n 还是 <= n |
| 整数溢出 | int 上限约 2.1×10⁹,累加/相乘要换 long long |
| 整数除法 | 7/2 = 3,要小数得用 double |
| 指针是否为空 | p->next 前先判 p |
| 递归出口 | 有没有、对不对 |
| 初始化 | 全局变量默认 0,局部变量是随机值 |
| 循环变量的修改 | i++ / i *= 2 / i-- 差别巨大 |
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
void insert(TreeNode*& root, int key) {
if (!root) {
root = new TreeNode(key);
return;
}
_______________________________
}
if (key < root->val)
insert(root->left, key);
else if (key > root->val)
insert(root->right, key);
if (key < root->val)
insert(root->right, key);
else if (key > root->val)
insert(root->left, key);
insert(root->left, key);
insert(root->right, key);
insert(root->right, key);
insert(root->left, key);ListNode* reverseLinkedList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* current = head;
while (current != nullptr) {
ListNode* next = current->next;
current->next = next;
prev = current;
current = next;
}
return prev;
}class Instrument {
public:
virtual void play() {
cout << "乐器在演奏声音" << endl;
}
virtual ~Instrument() {}
};
class Piano : public Instrument {
public:
void play() override {
cout << "钢琴:叮咚叮咚" << endl;
}
};
class Guitar : public Instrument {
public:
void play() override {
cout << "吉他:咚咚当当" << endl;
}
};
int main() {
Instrument* instruments[2];
instruments[0] = new Piano();
instruments[1] = new Guitar();
for (int i = 0; i < 2; ++i) {
instruments[i]->play();
}
for (int i = 0; i < 2; ++i) {
delete instruments[i];
}
return 0;
}class Instrument {
public:
void play() {
cout << "乐器在演奏声音" << endl;
}
virtual ~Instrument() {}
};
class Piano : public Instrument {
public:
void play() override {
cout << "钢琴:叮咚叮咚" << endl;
}
};
class Guitar : public Instrument {
public:
void play() override {
cout << "吉他:咚咚当当" << endl;
}
};
int main() {
Instrument* instruments[2];
instruments[0] = new Piano();
instruments[1] = new Guitar();
for (int i = 0; i < 2; ++i) {
instruments[i]->play();
}
for (int i = 0; i < 2; ++i) {
delete instruments[i];
}
return 0;
}class Vehicle {
private:
string brand;
public:
Vehicle(string b) : brand(b) {}
void setBrand(const string& b) { brand = b; }
string getBrand() const { return brand; }
virtual void move() const {
cout << brand << " is moving..." << endl;
}
};
class Car : public Vehicle {
private:
int seatCount;
public:
Car(string b, int seats) : Vehicle(b), seatCount(seats) {}
void showInfo() const {
cout << "This car is a " << getBrand()
<< " with " << seatCount << " seats." << endl;
}
void move() const override {
cout << getBrand() << " car is driving on the road!" << endl;
}
};
class Bike : public Vehicle {
public:
Bike(string b) : Vehicle(b) {}
void move() const override {
cout << getBrand() << " bike is cycling on the path!" << endl;
}
};
int main() {
Vehicle* v1 = new Car("Toyota", 5);
Vehicle* v2 = new Bike("Giant");
v1->move();
v2->move();
delete v1;
delete v2;
return 0;
}- 1.A 下面代码实现一个二叉排序树的插入函数(没有相同的数值),横线处应填入…
- 2.B 有关下面C++代码的说法正确的是( )。…
- 3.A 下面的代码片段用于反转单链表,请进行( )修改,使其能正确实现相应功…
- 4.D 下列关于命名空间的说法错误的是( )。…
- 5.D 下列关于类的说法,错误的是( )。…
- 6.C 执行如下代码,会输出 钢琴:叮咚叮咚 和 吉他:咚咚当当。这体现了面…
- 7.C 关于以下代码,说法正确的是( )。 第页共页…
- 8.C 下面代码中v1 和v2 调用了相同接口 move() ,但输出结果不…
- 9.B 下面有关格雷码的说法,错误的是( )。…
- 10.C 有关下面C++代码的说法,正确的是( )。…
int gcd(int a, int b) {
while (b != 0) {
______________________
}
return a;
}#include <iostream>
using namespace std;
class circular_queue {
private:
int *arr; // 数组用于存储队列元素
int capacity; // 队列容量
int front; // 队头指针
int rear; // 队尾指针
public:
circular_queue(int size) {
capacity = size + 1; // 为了避免队列满时与队列空时指针相等的情况,多预留一个空间
arr = new int[capacity];
front = 0;
rear = 0;
}
~circular_queue() {
delete[] arr;
}
bool is_empty() {
return front == rear;
}
bool is_full() {
________________ // 在此处填入代码
}
void en_queue(int data) {
if (is_full()) {
cout << "队列已满,无法入队!" << endl;
return -1;
}
arr[rear] = data;
rear = (rear + 1) % capacity;
return 1;
}
int de_queue() {
if (is_empty()) {
cout << "队列为空,无法出队!" << endl;
return -1; // 出队失败,返回一个特殊值
}
int data = arr[front];
front = (front + 1) % capacity;
return data;
}
};- 11.B 通讯卫星在通信网络系统中主要起到( )的作用。…
- 12.B 3 位格雷编码的正确顺序是( )。…
- 13.C 线性筛法与埃氏筛法相比的优势是( )。…
- 14.C 以下代码使用了辗转相除法求解最大公因数,请在横线处填入( ),使其能…
- 15.B 向一个栈顶为hs的链式栈中插入一个指针为s的结点时,应执行( )。…
- 16.A 下面定义了一个循环队列的类,请补全判断队列是否满的函数,横向上应填写…
- 17.A ( )是位格雷编码。…
- 18.B 代码同上一题,代码执行结果是( )。…
- 19.C 3位格雷编码中,编码 101 之后的下一个编码不可能是( )。…
- 20.B 关于格雷编码(Gray Code),下列说法正确的是( )。…
④今日打卡 · 点一下就能勾选
- 列表对比指针与引用的五项区别
- 写出一个会因浅拷贝崩溃的类,再用深拷贝修好
- 背出内存管理四条铁律,各说一个违反的后果
- 推导归并排序的 O(n log n):层数 × 每层工作量
- 背出主定理速记表 6 条,各配一个算法
- 按「题目特征 → 首选算法」表,给 5 道真题选算法并说明理由
- 把本日 20 道客观题做完,错题标记出来
动态规划 · 线性 DP
①本日知识点 · 动态规划 · 线性 DP
定状态 → 写转移 → 定边界 → 定答案;先手算前 5 项对拍。
本组 8 道题全部来自 GESP 真题,按「动态规划 · 线性 DP」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
这个游戏总共有 N 关,每关都有 M 个通道,你需要选择一个通道并通往后续关卡。其中,第 i 个通道可以让你前进 a_i 关,也就是说,如果你现在在第 x 关,那么选择第 i 个通道后,你将直接来到第 x+a_i 关(特别地,如果 x + a_i ≥q N,那么你就通关了)。此外,当你顺利离开第 s 关时,你还将获得 b_s 分。
游戏开始时,你在第 0 关。请问,你通关时最多能获得多少总分。
接下来一行 M 个用单个空格隔开的整数 a_0,a_1…,a_{M-1}。保证 1≤ a_i ≤ N。
接下来一行 N 个用单个空格隔开的整数 b_0,b_1…,b_{N-1}。保证 |b_i|≤ 10^5。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 6 2 2 3 1 0 30 100 30 30 | 131 |
| 2 | 6 2 2 3 1 0 30 100 30 -1 | 101 |
你可以在第 0 关选择第 1 个通道,获得 1 分并来到第 3 关;随后再选择第 0 个通道,获得 100 分并来到第 5 关;最后任选一个通道,都可以获得 30 分并通关。如此,总得分为 1+100+30=131。
样例解释 2
请注意,一些关卡的得分可能是负数。
数据范围
对于 20% 的测试点,保证 M=1。
对于 40% 的测试点,保证 N ≤ 20;保证 M≤ 2。
对于所有测试点,保证 1 ≤ N ≤ 10^4;保证 1 ≤ M≤ 100。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
共 N 关(编号 0 ~ N−1),每关有 M 个通道,第 i 个通道可以前进 aᵢ 关(若 x + aᵢ ≥ N 则通关)。顺利离开第 s 关时获得 bₛ 分(可为负)。从第 0 关开始,求通关时的最高总分。
💡人话翻译:典型的"从终点往回推"的 DP。
设 f[v] = "从第 v 关开始、最终通关能拿到的最高分"。那么 f[v] = b_v + maxᵢ f[v + aᵢ],其中 越界(v + aᵢ ≥ N)时 f = 0。
因为 v + aᵢ > v,所以从 N−1 往 0 倒着递推即可,答案就是 f[0]。
🔍 关键词提取
倒序 DP状态定义越界处理负数得分
已知条件
项目说明
输入第一行 N、M;第二行 M 个 aᵢ;第三行 N 个 bᵢ
输出最高总分
数据范围1 ≤ N ≤ 10⁴,1 ≤ M ≤ 100
分数范围|bᵢ| ≤ 10⁵(可为负)
通关条件位置 ≥ N
需要解决的问题
状态怎么设?f[v]:从第 v 关出发能获得的最高总分
为什么倒着推?因为 f[v] 依赖 f[v + aᵢ](更大的下标),所以按 v 从大到小计算
越界怎么算?v + aᵢ ≥ N 表示这一步就通关了,之后没有关卡可走,所以那一项取 0
🧠 状态
f[v]:从第 v 关开始的最高总分
答案 = f[0]
倒序计算(从 N−1 到 0)
规模 O(N)
📐 转移
枚举 M 个通道
f[v] = b_v + max f[v + aᵢ]
越界时该通道的 f 取 0
取所有通道的最大值
⚠️ 负数处理
bᵢ 可能为负
所以不能"能拿就拿"
必须比较所有通道
越界项 0 是"通关即停"
⚠️ 易错点
正序递推(依赖关系反了)
越界项当成负无穷或跳过
f 数组开小导致越界
用 int 忘了和可能较小但类型仍应够用
从最后一关开始往前推。f[v] = b_v + max(f[v+2], f[v+3])。
1
v = 5(最后一关)
两个通道都越界(5 + 2 = 7 ≥ 6,5 + 3 = 8 ≥ 6)
max 项都是 0
f[5] = b₅ + 0 = 30
f[5] = 30
2
v = 4
两个通道同样越界
f[4] = b₄ + 0 = 30
f[4] = 30
3
v = 3
通道 a=2 → 走到第 5 关 → f[5] = 30
通道 a=3 → 走到第 6 关 → 越界 → 0
f[3] = b₃ + max(30, 0) = 100 + 30 = 130
f[3] = 130
4
v = 2
a=2 → f[4] = 30;a=3 → f[5] = 30
f[2] = 30 + 30 = 60
f[2] = 60
5
v = 1
a=2 → f[3] = 130;a=3 → f[4] = 30
f[1] = 0 + max(130, 30) = 130
f[1] = 130
6
v = 0
a=2 → f[2] = 60;a=3 → f[3] = 130
f[0] = 1 + max(60, 130) = 131
✅ f[0] = 131
vb_vf[v+2]f[v+3]f[v]
530越界 0越界 030
430越界 0越界 030
310030越界 0130
230303060
1013030130
0160130131
答案 131 ✓ 与样例解释的路径(0 → 3 → 5 → 通关)一致
🔑对照样例解释验证:0 关选 a=3 → 到第 3 关(得 1 分);3 关选 a=2 → 到第 5 关(得 100 分);5 关任选 → 通关(得 30 分)。总分 1 + 100 + 30 = 131 ✓。
我们的 f 值也正好是这条路径的和,说明状态设计正确。
🧮 样例 2:把最后的 30 改成 −1
只有 b₅ 从 30 变成 −1,结果却从 131 变成 101——这说明"负分关卡要尽量跳过"。
vb_vf[v+2]f[v+3]f[v]
5−100−1
4300030
3100−10100
23030−160
1010030100
0160100101
1
关键在 v = 3
a=2 → 到第 5 关,那段只能拿 −1 分
a=3 → 直接越界通关,拿 0 分
所以要选 a=3,避免踩到负分关
f[3] = 100 + max(−1, 0) = 100
f[3] = 100(而不是 99)
2
连锁影响
f[1] 原本用 f[3] = 130,现在用 100
f[0] = 1 + max(f[2], f[3]) = 1 + max(60, 100) = 101
比样例 1 少了 29(正好是 −1 与 30 的差 31?)
实际差是 131 − 101 = 30
✅ 答案 101
⚠️这个对比非常重要:负分关卡的存在意味着不能贪心地"尽量往前走"——有时提前通关反而更优。
DP 的 max 恰好处理了这种取舍:它在"继续走"和"直接通关"之间选更划算的。而越界项取 0(而不是负无穷)正是"通关即停不扣分"的体现。
🟢 倒序 DP(推荐) 推荐
f[v] = b_v + max f[v + aᵢ],从 N−1 推到 0
时间 O(NM) = 10⁶
N = 10⁴、M = 100 时轻松通过
代码 15 行
空间 O(N)
💡转移式的直觉:f[v] 表示"站在第 v 关时的最优前景",等于"这一关的分"加上"跳到下一关后的最优前景"。越界时下一关的前景是 0(已通关)。
🟠 贪心:每关都选最远的通道
总选 a 最大的通道,尽快通关
看起来"少走几关更好"
但忽略了 b 值
样例 1 会错(选远处可能跳过 100 分)
无正确性保证
⚠️为什么贪心不行:如果第 3 关有 100 分,而"选最远通道"会跳过它,那贪心就亏了。得分与路径长度并无单调关系,所以必须 DP。
📈 性能对比
方案复杂度正确性
倒序 DPO(NM)✅ 最优
贪心选最远O(N)❌ 有反例
第一行输入 N 和 M,第二行输入各通道前进关卡数,第三行输入各关得分。
输入数据6 2
2 3
1 0 30 100 30 30
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int a[105], b[10005];
long long f[10005 + 105]; // 多开一些,方便越界取 0
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) scanf("%d", &a[i]);
for (int i = 0; i < N; i++) scanf("%d", &b[i]);
// 从最后一关倒推到第 0 关
for (int v = N - 1; v >= 0; v--) {
long long best = 0; // 直接通关:后续前景为 0
for (int i = 0; i < M; i++) {
int nxt = v + a[i];
if (nxt < N) best = max(best, f[nxt]);
// nxt >= N 表示这一步就通关,前景 0,不影响 max
}
f[v] = b[v] + best;
}
printf("%lld\n", f[0]);
return 0;
}
🔑为什么 best 初值取 0?因为"选择某个通道后如果越界就直接通关",通关之后不再扣分也不加分,所以那一条路的前景就是 0。
把 best 初值设为 0,相当于默认"至少可以直接通关拿 0 分",再与各个通道比较取更优。这与"倒序递推 + 越界取 0"是两种等价的写法。
📖 关键几行怎么看
代码作用为什么这样写
f 数组开大一点越界保护避免 f[v + aᵢ] 越界访问
for (v = N−1; v >= 0; v--)倒序f[v] 依赖更大的下标
long long best = 0初值直接通关的前景是 0
if (nxt < N)越界判断只有没通关才需要看后续
f[v] = b[v] + best转移本关得分 + 后续最优前景
⚠️四个坑:① 正序递推(依赖关系反了,结果全错);② best 初值取负无穷而不是 0(会漏掉"直接通关"这条路);③ 忘记判断 nxt < N 导致数组越界;④ 用 int 存累加和(N × |b| 可达 10⁹ 量级,建议 long long)。
写完程序后,用这些数据自查一遍:
输入答案考察点
6 2
2 3
1 0 30 100 30 30131题面样例 1
6 2
2 3
1 0 30 100 30 -1101题面样例 2(末尾为负分,提前通关更优)
1 1
1
55只有一关,选通道即通关
3 1
1
-1 -2 -3-6只能一路向前:(−1) + (−2) + (−3) = −6
3 2
1 3
10 10 1030f[1]=20,故 f[0]=10+20=30(跳过第 2 关更划算)
✅自查清单:① 倒序推吗?② best 初值是 0 吗?③ 判了越界吗?
🚨 易错点清单
⚠️正序递推:f[v] 依赖 f[v + aᵢ],必须倒着推。
⚠️best 初值取负无穷:应取 0(代表"直接通关")。
⚠️数组越界:注意先判断 v + aᵢ < N。
时间复杂度
O(NM)
空间复杂度
O(N + M)
N, M 最大
10⁴ × 100
运算量
约 10⁶
时间怎么算的?
外层 v 遍历 N 次
内层枚举 M 个通道
合计 N × M = 10⁶
空间都用在哪?
需要存 a、b 和 f 数组。
✅ 约 100 万次操作,瞬间完成。本题的难点在"想到倒着推"以及"越界项取 0"这两个细节。
// 倒序 DP 的适用特征
// 1. 状态 v 只能"前进"到 v + a_i(不能后退)
// 2. 问的是"从起点出发能获得的最优值"
// 3. 边界在"越界/终点"处,且边界值容易确定
// -> 从后往前推
// 通用骨架
for (int v = N - 1; v >= 0; v--) {
long long best = 终止值; // 直接结束时的收益
for (每个后继 nxt)
if (合法(nxt)) best = max(best, f[nxt]);
f[v] = 本步收益 + best;
}
// 答案 = f[起点]
// 与"正序 DP"的区别
// 正序:f[v] 表示"到达 v 时的最优值",转移 f[v] -> f[v + a]
// 倒序:f[v] 表示"从 v 出发的最优值",转移由后继回推
// 两种写法等价,但"倒序"往往更容易处理"终点"和"越界"
// 类似题目
// - 跳格子最大得分
// - 树上从叶子往根的最优值
// - 有向无环图上的最长/最短路径
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
倒序 DP从终点往起点推跳跃类、有向无环图上的最优路径
越界取 0直接结束的收益所有"走到边界即结束"的 DP
负数得分必须比较所有后继不能贪心,必须 DP
🌟思考题:如果题目改成"必须恰好走 K 关才能通关",DP 要怎么改?(提示:需要增加一维"已经走了几关",即 f[v][k]。"附加约束"往往会带来"状态维度增加",这也是 DP 题难度上升的主要来源。)
#include <bits/stdc++.h>
using namespace std;
int a[105], b[10005];
long long f[10005 + 105]; // 多开一些,方便越界取 0
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) scanf("%d", &a[i]);
for (int i = 0; i < N; i++) scanf("%d", &b[i]);
// 从最后一关倒推到第 0 关
for (int v = N - 1; v >= 0; v--) {
long long best = 0; // 直接通关:后续前景为 0
for (int i = 0; i < M; i++) {
int nxt = v + a[i];
if (nxt < N) best = max(best, f[nxt]);
// nxt >= N 表示这一步就通关,前景 0,不影响 max
}
f[v] = b[v] + best;
}
printf("%lld\n", f[0]);
return 0;
}// 倒序 DP 的适用特征
// 1. 状态 v 只能"前进"到 v + a_i(不能后退)
// 2. 问的是"从起点出发能获得的最优值"
// 3. 边界在"越界/终点"处,且边界值容易确定
// -> 从后往前推
// 通用骨架
for (int v = N - 1; v >= 0; v--) {
long long best = 终止值; // 直接结束时的收益
for (每个后继 nxt)
if (合法(nxt)) best = max(best, f[nxt]);
f[v] = 本步收益 + best;
}
// 答案 = f[起点]
// 与"正序 DP"的区别
// 正序:f[v] 表示"到达 v 时的最优值",转移 f[v] -> f[v + a]
// 倒序:f[v] 表示"从 v 出发的最优值",转移由后继回推
// 两种写法等价,但"倒序"往往更容易处理"终点"和"越界"
// 类似题目
// - 跳格子最大得分
// - 树上从叶子往根的最优值
// - 有向无环图上的最长/最短路径在一轮游戏操作中,你可以选择将 n 减去 a,或是将 n 减去 b。游戏将会进行多轮操作,直到当 n ≤q c 时游戏结束。
你想知道游戏结束时有多少种不同的游戏操作序列。两种游戏操作序列不同,当且仅当游戏操作轮数不同,或是某一轮游戏操作中,一种操作序列选择将 n 减去 a,而另一种操作序列选择将 n 减去 b。如果 a=b,也认为将 n 减去 a 与将 n 减去 b 是不同的操作。
由于答案可能很大,你只需要求出答案对 10^9 + 7 取模的结果。
一行四个整数 n,a,b,c。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 1 1 1 1 | 1 |
| 2 | 114 51 4 1 | 176 |
| 3 | 114514 191 9 810 | 384178446 |
- 对 20% 的数据,a=b=c=1,n ≤q 30。
- 对 40% 的数据,c = 1,n ≤q 10^3。
- 对全部的测试数据,保证 1 ≤q a,b,c ≤q n ≤q 2 × 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定四个正整数 n、a、b、c。每轮操作可以把 n 减去 a 或减去 b,直到 n ≤ c 时游戏结束。问游戏结束时共有多少种不同的操作序列。(若 a = b,"减 a"与"减 b"仍视为不同的操作。)答案对 10⁹ + 7 取模。
💡人话翻译:这是"路径计数"型递推。设 cnt[v] = 从当前值为 v 开始、游戏彻底结束的序列条数。
若 v ≤ c 游戏已经结束——此时空序列算 1 条;否则 cnt[v] = cnt[v − a] + cnt[v − b]。
答案就是 cnt[n],一次线性递推即可,复杂度 O(n)。
🔍 关键词提取
路径计数线性递推取模边界处理
已知条件
项目说明
输入一行四个整数 n、a、b、c
输出序列条数对 10⁹+7 取模
数据范围1 ≤ a, b, c ≤ n ≤ 2 × 10⁵
结束条件n ≤ c 时立即结束
注意即使 a = b,减 a 与减 b 也视为不同操作
需要解决的问题
状态怎么设?cnt[v]:从数值 v 开始能产生的序列条数
边界是什么?v ≤ c 时游戏已结束,只剩"什么都不做"这 1 条空序列
为什么不用管"提前结束"?因为 a、b 都 ≥ 1,n 严格递减,第一次满足 n ≤ c 就是结束点,递推自动处理了这一点
🧠 状态
cnt[v]:从 v 开始的序列条数
答案 = cnt[n]
v 从 0 到 n 递推
规模 O(n)
📐 边界
v ≤ c → 游戏已结束
此时只剩空序列 → cnt[v] = 1
这是递推的"终止条件"
注意不是 0
🔁 转移
减 a → 走到 v−a
减 b → 走到 v−b
两种操作互不干扰,相加
a = b 时也要算两次
⚠️ 易错点
把 cnt[v ≤ c] 写成 0(应写 1)
忘记取模
a = b 时只算一次(应算两次)
用 int 存中间和(会溢出)
初始 n = 1 ≤ c = 1,游戏立刻结束。
1
边界直接命中
因为 n ≤ c,一次操作都不用做
只有"空序列"这 1 种
cnt[1] = 1
✅ 输出 1
这一组数据专门用来确认"空序列算 1 条"这个约定
🔑为什么空序列要算 1 条?题目说"游戏将会进行多轮操作,直到当 n ≤ c 时游戏结束",并没有强制"必须至少操作一次"。所以当初始就满足 n ≤ c 时,"什么都不做的序列"就是一种合法的操作序列。
🧮 样例 2:n = 114,a = 51,b = 4,c = 1
这组数据的 a、b 差得很大,我们用递推来算(取模前先看结构)。
1
边界
对所有 v ≤ 1,cnt[v] = 1
即 cnt[0] = cnt[1] = 1
cnt[0..1] = 1
2
递推规律
对 v > 1:cnt[v] = cnt[v − 51] + cnt[v − 4]
(当 v − 51 < 0 时那一项按 0 计)
例如 cnt[2] = cnt[−49] + cnt[−2] = 0 + 0 = 0
cnt[3] = 0 + 0 = 0
cnt[4] = cnt[−47] + cnt[0] = 0 + 1 = 1
cnt[5] = cnt[−46] + cnt[1] = 0 + 1 = 1
cnt[6] = 0 + cnt[2] = 0
cnt[7] = 0 + cnt[3] = 0
cnt[8] = 0 + cnt[4] = 1
cnt[9] = 0 + cnt[5] = 1
…(可以看出来值与模 4 的余数有关)
规律:只有能走到 ≤ c 的才有计数
3
最终结果
一路递推到 v = 114
cnt[114] = 176
(过程中每一步都取模 10⁹+7)
✅ 输出 176
📊 关键理解:为什么"减到负数"也算游戏结束
这是本题最容易被忽略的细节:如果当前 v > c,而减去 a 之后得到 v − a < 0,那么这个结果显然也满足 ≤ c——游戏照样结束。
所以判定条件应该写成"v − a ≤ c 就计 1 条",而不是"先检查是否为负数、负数就返回 0"。把负数误判成 0,会漏掉一大批合法序列——例如样例 2 的答案就会从 176 变成 10。
⚠️实现上的小技巧:写一个取值函数 get(v) = (v <= c) ? 1 : cnt[v],它天然覆盖了负数情形(因为负数一定 ≤ c),从而避免下标越界、也不会漏解。
不要额外加一条 if (v < 0) return 0;,那会引入错误。
🟢 线性递推(推荐) 推荐
cnt[v] = cnt[v−a] + cnt[v−b],v 从 0 递推到 n
时间 O(n)
n = 2 × 10⁵ 时约 2 × 10⁵
代码 12 行
空间 O(n)
💡递推方向:从小的 v 往大的 v 推(因为 v−a、v−b 都更小)。也可以反过来理解为"倒着推",本质是同一件事。
🟠 枚举所有操作序列
递归/搜索生成所有可能的减 a、减 b 组合
序列条数随 n 指数增长
n = 30 时已经不可行
完全不能用于 n = 2 × 10⁵
只能过极小数据
⚠️为什么必须用 DP:本题的答案本身就是"序列条数",而这个条数会随 n 急剧增长(样例 3 的答案已经高达 3.8 亿)。所以只能"计数"而不能"枚举"。
📈 性能对比
方案复杂度可行性
线性递推O(n)✅ 稳过
枚举序列指数级❌ 不可行
输入 n a b c,程序会递推计算序列条数(演示规模内给出精确值)。
输入 n a b c
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long cnt[200005];
int main() {
int n, a, b, c;
scanf("%d %d %d %d", &n, &a, &b, &c);
auto get = [&](int v) -> long long {
// 只要减完之后 v <= c 就算游戏结束(减成负数也一样结束)
if (v <= c) return 1; // 已结束:只剩空序列 1 条
return cnt[v];
};
for (int v = 0; v <= n; v++) {
if (v <= c) cnt[v] = 1;
else cnt[v] = (get(v - a) + get(v - b)) % MOD;
}
printf("%lld\n", cnt[n]);
return 0;
}
🔑为什么 v ≤ c 时取 1 而不是 0?因为 cnt[v] 的定义是"从 v 开始、游戏结束时的序列条数"。若 v 已经 ≤ c,游戏当场结束,只有"什么都不做"这一条序列。
如果这里写成 0,整个递推会全部算出 0——这是本题最容易踩的坑。
📖 关键几行怎么看
代码作用为什么这样写
if (v < 0) return 0;越界保护走不到的分支计 0
if (v <= c) return 1;终止条件已结束 → 空序列 1 条
cnt[v] = get(v-a) + get(v-b)转移两种操作分别产生各自的后续序列
% MOD取模防止溢出
⚠️四个坑:① v ≤ c 写成返回 0;② 忘记取模(中间和会超出 long long);③ a = b 时只加一次(题目明确规定要算作两种不同操作);④ 递推方向写反。
写完程序后,用这些数据自查一遍:
输入答案考察点
1 1 1 11题面样例 1(初始就结束,空序列计 1)
114 51 4 1176题面样例 2
114514 191 9 810384178446题面样例 3(需取模)
5 1 1 116a = b = 1:从 v=2 起每步翻倍 → 2⁴ = 16
3 3 3 12一次操作就能结束(3 − 3 = 0 ≤ 1),两种操作各算一次
✅自查清单:① 边界是 1 吗?② 每一步取模了吗?③ a = b 时算两次吗?
🚨 易错点清单
⚠️边界写成 0:v ≤ c 时必须返回 1(空序列)。
⚠️忘记取模:序列条数会非常大,必须每一步取模。
⚠️a = b 只算一次:题目明确"减 a"与"减 b"算不同操作。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
2 × 10⁵
运算量
约 2 × 10⁵
时间怎么算的?
外层 v 从 0 到 n
每次 O(1) 的加法与取模
合计 O(n)
空间都用在哪?
一个长度 n+1 的计数数组。
✅ 约 20 万次操作,瞬间完成。关键在于把"序列条数"看成可以递推的量。
// 路径计数型递推的模板
long long get(int v) {
if (v < 0) return 0;
if (v <= c) return 1; // 终止状态
return cnt[v];
}
for (int v = 0; v <= n; v++)
cnt[v] = (v <= c) ? 1 : (get(v - a) + get(v - b)) % MOD;
// 同类问题:走台阶
// 每次走 1 级或 2 级,走到第 n 级有多少种走法
// f[0] = f[1] = 1; f[i] = f[i-1] + f[i-2];
// 与本题的递推形式完全一致,区别只在"终止条件"
// 关键思维:问"有多少种方案"时,优先想递推/DP
// 因为方案数往往很大,枚举不可行,但计数可以递推
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
路径计数cnt[v] = Σ cnt[后继]走台阶、掷骰子、操作序列计数
终止条件取 1已结束 = 空方案 1 条所有"到达终点即结束"的计数题
取模每步取模防溢出答案可能很大的计数题
🌟思考题:如果题目改成"每次可以减去 a、b 或 c(三个选择)",递推式要改哪里?(提示:只需在转移里多加一项 get(v − c),其余完全不动。这说明"选择的数量"只影响转移式的项数,不影响整体的递推框架。)
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long cnt[200005];
int main() {
int n, a, b, c;
scanf("%d %d %d %d", &n, &a, &b, &c);
auto get = [&](int v) -> long long {
// 只要减完之后 v <= c 就算游戏结束(减成负数也一样结束)
if (v <= c) return 1; // 已结束:只剩空序列 1 条
return cnt[v];
};
for (int v = 0; v <= n; v++) {
if (v <= c) cnt[v] = 1;
else cnt[v] = (get(v - a) + get(v - b)) % MOD;
}
printf("%lld\n", cnt[n]);
return 0;
}// 路径计数型递推的模板
long long get(int v) {
if (v < 0) return 0;
if (v <= c) return 1; // 终止状态
return cnt[v];
}
for (int v = 0; v <= n; v++)
cnt[v] = (v <= c) ? 1 : (get(v - a) + get(v - b)) % MOD;
// 同类问题:走台阶
// 每次走 1 级或 2 级,走到第 n 级有多少种走法
// f[0] = f[1] = 1; f[i] = f[i-1] + f[i-2];
// 与本题的递推形式完全一致,区别只在"终止条件"
// 关键思维:问"有多少种方案"时,优先想递推/DP
// 因为方案数往往很大,枚举不可行,但计数可以递推| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 | 7 |
| 2 | 10 | 274 |
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
一共有 N 个台阶,每步可以走 1 个、2 个或 3 个台阶。求走完 N 个台阶共有多少种不同的方案。
💡人话翻译:最经典的递推入门题。考虑最后一步:它可能是走 1 步、2 步或 3 步。
所以 f[N] = f[N−1] + f[N−2] + f[N−3]。
也就是把"从 0 级走到 N 级"拆成"先走到 N−1 再走 1 步"、"先走到 N−2 再走 2 步"、"先走到 N−3 再走 3 步"三种情况相加。这就是"三项斐波那契"(Tribonacci)。
🔍 关键词提取
递推最后一步划分三项斐波那契边界处理
已知条件
项目说明
输入一个整数 N
输出走法的总数
数据范围1 ≤ N ≤ 60
每步选择1、2 或 3 个台阶
方案区分按"每步走多少"的序列区分
需要解决的问题
怎么划分情况?按第一步(或最后一步)走的台阶数分三类:1、2、3
初始值怎么定?f[0] = 1(0 级台阶只有"什么都不走"1 种)、f[1] = 1、f[2] = 2
会不会溢出?N = 60 时约 7 × 10¹⁵,在 long long 范围内(约 9.2 × 10¹⁸)
🧠 划分依据
看第一步走几级
走 1 级 → 剩下 N−1 级
走 2 级 → 剩下 N−2 级
走 3 级 → 剩下 N−3 级
📐 初始值
f[0] = 1(不走也算一种)
f[1] = 1
f[2] = 2
从 f[3] 起用递推
🔢 数值增长
1, 1, 2, 4, 7, 13, 24, 44, …
增长约 1.839 倍
N = 60 时约 7 × 10¹⁵
正好在 long long 内
⚠️ 易错点
f[0] 写成 0 导致后面全错
用 int(N = 60 时溢出)
下标越界(N ≤ 2 时不能直接递推)
把"台阶数"和"方案数"搞混
先按递推算,再手工枚举核对。
1
初始值
f[0] = 1(一级都不走,也只有这一种"走法")
f[1] = 1(只能一次走 1 级)
f[2] = 2(1+1 或 一次走 2 级)
f = [1, 1, 2, …]
2
递推
f[3] = f[2] + f[1] + f[0] = 2 + 1 + 1 = 4
f[4] = f[3] + f[2] + f[1] = 4 + 2 + 1 = 7
f[4] = 7
📊 手工枚举 N = 4 的所有方案
序号走法(每步台阶数)步数
11 + 1 + 1 + 14
21 + 1 + 23
31 + 2 + 13
42 + 1 + 13
51 + 32
63 + 12
72 + 22
共 7 种 ✓ 与递推一致
🔑注意"步数不同也算不同方案":1+3 和 3+1 是两种方案,因为它们每一步的走法序列不同。这与"只问用了几步"的问题完全不同——读题时要看清"方案"的定义。
🧮 样例 2:N = 10,答案 274
继续把递推表算下去。
N012345678910
f[N]1124713244481149274
f[10] = 274 ✓ 与样例一致
1
验证几个值
f[5] = f[4]+f[3]+f[2] = 7+4+2 = 13 ✓
f[6] = 13+7+4 = 24 ✓
f[7] = 24+13+7 = 44 ✓
f[8] = 44+24+13 = 81 ✓
f[9] = 81+44+24 = 149 ✓
f[10] = 149+81+44 = 274 ✓
全部吻合
⚠️关于数据范围 N ≤ 60:这题如果用 O(2^N) 的搜索枚举所有方案,N = 60 时完全不可行;但递推只要 O(N) 次加法。
而且 f[60] 约为 7 × 10¹⁵,恰好超出 int(约 2.1 × 10⁹)但仍在 long long 内——这也是题目把 N 限制在 60 的原因之一。
🟢 线性递推(推荐) 推荐
f[i] = f[i−1] + f[i−2] + f[i−3]
时间 O(N)
N = 60 时 60 次加法
代码 10 行
空间可优化到 O(1)
💡递推的本质:把"大问题"按第一步的走法拆成三个"小问题"。这种"按第一步/最后一步分类"是递推与 DP 最常用的切入点。
🟠 搜索枚举所有走法
递归生成所有"每步走几级"的序列
方案数约 1.839^N
N = 40 时已约 10¹⁰ 种
N = 60 完全不可行
只能处理 N ≤ 15 左右
⚠️对比量级:搜索要枚举"所有方案",而递推只算"方案的个数"——这正是 DP 的核心价值:用状态合并掉大量重复的子结构。
📈 性能对比
方案复杂度(N = 60)可行性
线性递推60 次加法✅ 瞬间
搜索枚举约 7 × 10¹⁵ 种❌ 不可行
输入台阶数 N,程序会递推给出方案数并展示每一步的值。
输入 N
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long f[70];
int main() {
int N;
scanf("%d", &N);
f[0] = 1; // 0 级台阶:只有"不走"1 种
f[1] = 1; // 1 级:只能走 1 步
f[2] = 2; // 2 级:1+1 或 2
for (int i = 3; i <= N; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3];
}
printf("%lld\n", f[N]);
return 0;
}
🔑为什么 f[0] = 1 而不是 0?因为递推式 f[3] = f[2] + f[1] + f[0] 中,f[0] 对应"一步走完 3 级"这种方案——它确实是一种合法方案,所以 f[0] 必须计为 1。
这体现了"初始值要结合实际含义来定":空问题的方案数是 1(不做任何事的方案)。
📖 关键几行怎么看
代码作用为什么这样写
f[0] = 1边界空走法算 1 种
f[1] = 1, f[2] = 2边界手工枚举得到
f[i] = f[i-1] + f[i-2] + f[i-3]递推按"第一步走几级"分三类
long long f[70]类型f[60] 约 7 × 10¹⁵,需 64 位
⚠️四个坑:① f[0] 写成 0;② 用 int(f[60] 会溢出);③ N ≤ 2 时直接访问 f[N] 是可以的(因为 f[0..2] 都赋了值),但循环要从 3 开始;④ 把"每步 1/2/3 级"误看成"每步必须走 3 级"。
写完程序后,用这些数据自查一遍:
输入答案考察点
47题面样例 1
10274题面样例 2
11只有 1 级
221+1 或 2
341+1+1、1+2、2+1、3
60运行验证最大值,验证 long long
✅自查清单:① f[0] = 1 吗?② 用 long long 吗?③ 递推式三项都对吗?
🚨 易错点清单
⚠️f[0] 写成 0:会导致 f[3] 少 1(应为 4),后续全错。
⚠️用 int:f[60] 约 7 × 10¹⁵,超出 int 范围。
⚠️循环起点错:应从 i = 3 开始(f[0..2] 已手工赋值)。
时间复杂度
O(N)
空间复杂度
O(N)
N 最大
60
运算量
60 次加法
时间怎么算的?
一次循环,每次三项加法
合计 O(N)
还可以只保留三个变量,把空间降到 O(1)
空间都用在哪?
一个长度 61 的数组(也可以只用 3 个变量滚动)。
✅ 常数级运算,瞬间完成。本题的价值在于"学会按第一步划分情况"这个递推思路。
// 三项递推(Tribonacci)模板
long long f[70];
f[0] = 1; f[1] = 1; f[2] = 2;
for (int i = 3; i <= N; i++) f[i] = f[i-1] + f[i-2] + f[i-3];
// 滚动变量版(空间 O(1))
long long a = 1, b = 1, c = 2;
for (int i = 3; i <= N; i++) {
long long d = a + b + c;
a = b; b = c; c = d;
}
// 答案 = c
// 本题的递推思路是"按第一步分类"
// 其实也算 DP:"状态 = 剩余台阶数","决策 = 这一步走几级"
// 状态转移:f[i] = Σ f[i - 每步可走的级数]
// 如果每步可选 1 ~ k 级,递推式就是 k 项之和
// 如果每步可选任意正整数级,方案数 = 2^(N-1)
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
三项递推按第一步分三类走台阶、铺砖、拆数字类计数
按第一步分类大问题拆小问题所有递推/DP 的切入口
初始值含义空问题算 1 种避免 f[0] 取错
🌟思考题:如果题目改成"每步可以走 1 到 N 级中的任意级"(即一次最多走多少不限),方案数是多少?(提示:那答案就是 2^(N−1)——因为可以把 N 个台阶之间的 (N−1) 个"缝隙"各自决定"是否在此处停一下"。从这个例子能看出:"可选步长集合"的改变会让递推式随之改变。)
#include <bits/stdc++.h>
using namespace std;
long long f[70];
int main() {
int N;
scanf("%d", &N);
f[0] = 1; // 0 级台阶:只有"不走"1 种
f[1] = 1; // 1 级:只能走 1 步
f[2] = 2; // 2 级:1+1 或 2
for (int i = 3; i <= N; i++) {
f[i] = f[i - 1] + f[i - 2] + f[i - 3];
}
printf("%lld\n", f[N]);
return 0;
}// 三项递推(Tribonacci)模板
long long f[70];
f[0] = 1; f[1] = 1; f[2] = 2;
for (int i = 3; i <= N; i++) f[i] = f[i-1] + f[i-2] + f[i-3];
// 滚动变量版(空间 O(1))
long long a = 1, b = 1, c = 2;
for (int i = 3; i <= N; i++) {
long long d = a + b + c;
a = b; b = c; c = d;
}
// 答案 = c
// 本题的递推思路是"按第一步分类"
// 其实也算 DP:"状态 = 剩余台阶数","决策 = 这一步走几级"
// 状态转移:f[i] = Σ f[i - 每步可走的级数]
// 如果每步可选 1 ~ k 级,递推式就是 k 项之和
// 如果每步可选任意正整数级,方案数 = 2^(N-1)小 A 会从某个车站出发,乘坐地铁环线到某个车站结束行程,这意味着小 A 至少会经过一个车站。小 A 不会经过一个车站多次。当小 A 乘坐地铁环线经过车站 i 时,小 A 会获得 a_i 点快乐值。请你安排小 A 的行程,选择出发车站与结束车站,使得获得的快乐值总和最大。
第二行,n 个整数 a_i,分别表示经过每个车站时获得的快乐值。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 -1 2 3 0 | 5 |
| 2 | 5 -3 4 -5 1 3 | 5 |
对于 40% 的测试点,保证 1≤q n≤q 2000。
对于所有测试点,保证 1≤q n≤q 2× 10^5,-10^9≤q a_i≤q 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
地铁环线有 n 个车站,站 i 的下一站是 i+1(站 n 的下一站是站 1)。小 A 从某站出发、到某站结束,至少经过一个车站,且不会重复经过同一车站。经过站 i 获得 aᵢ 点快乐值(可正可负)。求最大快乐值总和。
💡人话翻译:由于只能"一路向前",行程就是环上的一段连续弧,长度可以是 1 ~ n(n = 从某站出发绕一整圈到它的前一站,每站只经过一次)。
所以这是经典的"环形最大子段和"问题。做法是把数组复制一倍 + 前缀和 + 单调队列,把"长度不超过 n 的最大子段和"在 O(n) 内求出。
🔍 关键词提取
环形最大子段和前缀和单调队列滑动窗口最小值
已知条件
项目说明
输入第一行 n;第二行 a₁…aₙ
输出最大快乐值总和
数据范围1 ≤ n ≤ 2 × 10⁵
快乐值−10⁹ ≤ aᵢ ≤ 10⁹(可为负)
行程环上连续弧,长度 1 ~ n
需要解决的问题
为什么长度上限是 n?因为不能重复经过车站;若弧长超过 n 就必然绕回来碰到走过的站
朴素做法为什么不行?枚举所有起点终点是 O(n²) = 4 × 10¹⁰,必须 O(n)
怎么做到 O(n)?复制一倍后,任意弧的和 = pre[e] − pre[s];固定终点 e,只要在长度为 n 的窗口内取最小的 pre即可——这用单调队列维护
🧠 模型
行程 = 环上连续弧
长度 ∈ [1, n]
求弧上元素和的最大值
经典"环形最大子段和"
🔧 复制一倍
把 a 复制成 2n 长度
任意弧都变成一段普通区间
再限定长度 ≤ n
避免分类讨论"跨环"
⚡ 单调队列
pre[i] 为前缀和
弧和 = pre[e] − pre[s]
固定 e,取窗口内最小 pre
队列维护递增的 pre
⚠️ 易错点
用 int(和可达 2 × 10¹⁴)
窗口大小写成 n+1 或 n−1
队列忘记弹出过期下标
n = 1 时特判
先把所有长度 ≤ 4 的弧列出来(环上连续)。
弧长候选弧(按环顺序)最大和
1[−1]、[2]、[3]、[0]3
2[−1,2]、[2,3]、[3,0]、[0,−1]5(2 + 3)
3[−1,2,3]、[2,3,0]、[3,0,−1]、[0,−1,2]5(2+3+0)
4[−1,2,3,0]4
最大 = 5 ✓(走车站 2 → 3)
🔑注意长度 3 的 [2,3,0] 也是 5,与长度 2 的 [2,3] 并列最优。这说明最优方案不唯一,但答案唯一。
另外注意负值 −1:它被"绕开"了——因为我们是从车站 2 出发到车站 3,不必经过车站 1。
🧮 样例 2:a = [−3, 4, −5, 1, 3]
这组数据的最优解跨过了"环的连接处",正好体现环形问题的特点。
1
先看"不跨环"的最大弧
线性数组 [−3, 4, −5, 1, 3] 的最大子段:
[4] = 4;[1,3] = 4;[4,−5,1,3] = 3
所以不跨环的最优是 4
不跨环最优 4
2
再看"跨环"的弧
跨环意味着弧"绕过"了数组的首尾相接处
例如 [1, 3, −3, 4]:从站 4 出发 → 站 5 → 站 1 → 站 2
和 = 1 + 3 + (−3) + 4 = 5
这比 4 更好!
跨环可得 5
3
验证长度限制
该弧长 4 ≤ n = 5 ✓
有没有长度为 5 的弧?= 整圈 = −3+4−5+1+3 = 0
所以不能更长(长度 5 本身合法但和只有 0)
最优就是 5
✅ 答案 5
最优行程:站 4 → 5 → 1 → 2,快乐值 1 + 3 − 3 + 4 = 5 ✓
⚠️这个样例是本类问题的"试金石":如果只做一维的普通最大子段和,会得到 4(而不是正确答案 5)——因为答案跨过了数组的"断点"。
复制一倍 + 限制窗口长度正是为了正确处理这种情况。
🟢 复制一倍 + 单调队列(推荐) 推荐
前缀和 + 滑动窗口最小值,一次 O(n) 扫描
时间 O(n)
n = 2 × 10⁵ 时约 4 × 10⁵
代码 25 行
空间 O(n)
💡核心等式:弧 [s+1, e] 的和 = pre[e] − pre[s]。固定 e,要最大化它就最小化 pre[s],而 s 的范围是 [e−n, e−1]。这就是"滑动窗口最小值",用单调队列 O(1) 摊还维护。
🟠 枚举起点终点
枚举所有弧,累加求和取最大
时间 O(n²)
n = 2000 时可行(40% 测试点)
n = 2 × 10⁵ 时 4 × 10¹⁰
必然超时
⚠️注意数据分档:n ≤ 200 得 20%、n ≤ 2000 得 40%,但想满分必须 O(n)。看到"n ≤ 2 × 10⁵"就该意识到 O(n²) 不可行。
📈 性能对比
方案复杂度(n = 2 × 10⁵)可行性
单调队列约 4 × 10⁵✅ 稳过
枚举起点终点约 4 × 10¹⁰❌ 超时
输入一组快乐值,程序会用环形算法求出最大值,并与暴力枚举互相验证。
输入快乐值
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[400005], pre[400005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
a[i + n] = a[i]; // 复制一倍
}
int N = 2 * n;
pre[0] = 0;
for (int i = 0; i < N; i++) pre[i + 1] = pre[i] + a[i];
// 单调队列:存前缀和的下标,保持 pre 递增
deque<int> dq;
dq.push_back(0);
long long ans = LLONG_MIN;
for (int e = 1; e <= N; e++) {
// 弹出超出窗口的下标(窗口是 [e - n, e - 1])
while (!dq.empty() && dq.front() < e - n) dq.pop_front();
// 用队首(窗口内最小的 pre)更新答案
ans = max(ans, pre[e] - pre[dq.front()]);
// 维护单调性后把 e 入队
while (!dq.empty() && pre[dq.back()] >= pre[e]) dq.pop_back();
dq.push_back(e);
}
printf("%lld\n", ans);
return 0;
}
🔑窗口为什么是 [e − n, e − 1]?e 是弧的右端点(在前缀和里是"第 e 个位置之后"),s 是左端点前一个位置。弧的长度 = e − s,要求 1 ≤ e − s ≤ n,所以 s ∈ [e − n, e − 1] ✓。
不同题目里"窗口长度"的定义容易搞混,建议先把长度约束写成 e − s 的不等式再推。
📖 关键几行怎么看
代码作用为什么这样写
a[i + n] = a[i]复制一倍把环形摊平成线性
pre[i + 1] = pre[i] + a[i]前缀和让区间和能 O(1) 求出
while (dq.front() < e - n) pop_front()窗口过期保证弧长 ≤ n
pre[e] - pre[dq.front()]更新答案队首是窗口内最小的 pre
while (... >= pre[e]) pop_back()维护单调保证队列里 pre 递增
⚠️四个坑:① 用 int(和可达 2 × 10¹⁴);② 窗口边界写错(应该是 e − n,对应"弧长 ≤ n");③ 忘记"先更新答案再压入 e"的顺序(否则可能出现长度 0 的弧);④ ans 初值取 0(应为负无穷,因为答案可能是负数)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
-1 2 3 05题面样例 1(走站 2 → 3)
5
-3 4 -5 1 35题面样例 2(跨环)
1
77只有一个车站
1
-7-7只有一个车站且为负,必须经过它
3
-1 -2 -3-1全为负,取最大的单个
4
1 1 1 14全为正,绕一整圈(经过全部 4 站一次)
✅自查清单:① 复制一倍了吗?② 窗口是 e−n 到 e−1 吗?③ ans 初值是负无穷吗?
🚨 易错点清单
⚠️ans 初值取 0:答案可能是负数(如全负数组),初值应取负无穷。
⚠️窗口边界错:要求弧长 ≤ n,对应 s ≥ e − n。
⚠️用 int:和可达 2 × 10¹⁴,需要 long long。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
2 × 10⁵
运算量
约 4 × 10⁵
时间怎么算的?
复制数组 O(n)
前缀和 O(n)
单调队列扫描 2n 次,每次摊还 O(1)
合计 O(n)
空间都用在哪?
需要存 2n 长度的数组与前缀和。
✅ 约 40 万次操作,瞬间完成。若只做一维 Kadane(不处理跨环),样例 2 会错答为 4。
// 环形最大子段和:两种经典做法
// 做法 A(推荐):复制一倍 + 前缀和 + 单调队列(本题代码)
// 做法 B:分类讨论
// ans = max(不跨环的最大子段和, 总和 − 不跨环的最小子段和)
// 注意:若"最小子段"就是整个数组,要特殊处理(对应"不能取空弧")
// 单调队列求滑动窗口最小值(通用模板)
deque<int> dq;
for (int i = 0; i < N; i++) {
while (!dq.empty() && dq.front() < i - k + 1) dq.pop_front(); // 过期
while (!dq.empty() && a[dq.back()] >= a[i]) dq.pop_back(); // 维护单调
dq.push_back(i);
// 此时 dq.front() 就是窗口 [i-k+1, i] 内最小值的下标
}
// 环形问题的通用思路
// 1. 复制一倍摊平成线性
// 2. 用"长度限制的滑动窗口"约束
// 3. 避免分类讨论"是否跨环"
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
环形 → 线性复制一倍所有环形区间问题
滑动窗口最小值单调队列 O(n)固定窗口长度的最值查询
前缀和 + 队列区间和转成前缀差子段和、区间统计类问题
🌟思考题:如果题目改成"弧长恰好为 k"(必须经过恰好 k 个车站),代码要怎么改?(提示:更简单——窗口大小固定成 k 而不是 n,即把 e − n 改成 e − k。这说明单调队列框架非常灵活,窗口大小就是"约束条件"的直接映射。)
#include <bits/stdc++.h>
using namespace std;
long long a[400005], pre[400005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
a[i + n] = a[i]; // 复制一倍
}
int N = 2 * n;
pre[0] = 0;
for (int i = 0; i < N; i++) pre[i + 1] = pre[i] + a[i];
// 单调队列:存前缀和的下标,保持 pre 递增
deque<int> dq;
dq.push_back(0);
long long ans = LLONG_MIN;
for (int e = 1; e <= N; e++) {
// 弹出超出窗口的下标(窗口是 [e - n, e - 1])
while (!dq.empty() && dq.front() < e - n) dq.pop_front();
// 用队首(窗口内最小的 pre)更新答案
ans = max(ans, pre[e] - pre[dq.front()]);
// 维护单调性后把 e 入队
while (!dq.empty() && pre[dq.back()] >= pre[e]) dq.pop_back();
dq.push_back(e);
}
printf("%lld\n", ans);
return 0;
}// 环形最大子段和:两种经典做法
// 做法 A(推荐):复制一倍 + 前缀和 + 单调队列(本题代码)
// 做法 B:分类讨论
// ans = max(不跨环的最大子段和, 总和 − 不跨环的最小子段和)
// 注意:若"最小子段"就是整个数组,要特殊处理(对应"不能取空弧")
// 单调队列求滑动窗口最小值(通用模板)
deque<int> dq;
for (int i = 0; i < N; i++) {
while (!dq.empty() && dq.front() < i - k + 1) dq.pop_front(); // 过期
while (!dq.empty() && a[dq.back()] >= a[i]) dq.pop_back(); // 维护单调
dq.push_back(i);
// 此时 dq.front() 就是窗口 [i-k+1, i] 内最小值的下标
}
// 环形问题的通用思路
// 1. 复制一倍摊平成线性
// 2. 用"长度限制的滑动窗口"约束
// 3. 避免分类讨论"是否跨环"street 来说,str + e + e + t 是满足条件的划分;而 s + tree + t 不是,因为子串 tree 中 e 出现了两次。额外地,小 A 还给出了价值 a_1,a_2,…,a_n,表示划分后长度为 i 的子串价值为 a_i。小 A 希望最大化划分后得到的子串价值之和。你能帮他求出划分后子串价值之和的最大值吗?
第二行,一个包含 n 个小写字母的字符串 s。
第三行,n 个正整数 a_1,a_2,…,a_n,表示不同长度的子串价值。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 6 street 2 1 7 4 3 3 | 13 |
| 2 | 8 blossoms 1 1 2 3 5 8 13 21 | 8 |
对于所有测试点,保证 1≤ n≤ 10^5,1≤ a_i≤ 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定长度 n 的小写字母串 s,把它划分成若干子串,要求每个子串内的字母都不重复。给定价值数组 a₁…aₙ,表示长度为 i 的子串价值为 aᵢ。求划分后价值之和的最大值。
💡人话翻译:这是"分割型 DP":dp[i] = 前 i 个字符能取得的最大价值,转移是枚举最后一段的长度:dp[i] = max(dp[i−len] + a[len])。
本量关键在于"len 最多只有 26"——因为小写字母只有 26 种,子串内字母不重复就意味着长度 ≤ 26。于是枚举量从 O(n) 降到 O(26)!
🔍 关键词提取
分割型 DP字母不重复抽屉原理O(26n)
已知条件
项目说明
输入第一行 n;第二行串 s;第三行 a₁…aₙ
输出最大价值之和
数据范围1 ≤ n ≤ 10⁵
价值范围1 ≤ aᵢ ≤ 10⁹
约束每个子串内每个字母至多出现一次
需要解决的问题
为什么长度最多 26?子串里字母不重复,而字母总共只有 26 种,所以长度 ≤ 26——这是本题的破题关键
怎么判断某段是否合法?从 i 往前逐字符扩展,用一个计数数组检测重复;一旦出现重复就停止
朴素做法为什么不行?若枚举所有长度就是 O(n²) = 10¹⁰,超时;靠"长度 ≤ 26"才降到 2.6 × 10⁶
🧠 状态定义
dp[i]:前 i 个字符的最大价值
dp[0] = 0
答案是 dp[n]
按前缀递推
🔁 转移
枚举最后一段的长度 len
要求 s[i−len .. i−1] 字母不重复
dp[i] = max(dp[i−len] + a[len])
取所有合法 len 的最大值
🔑 关键观察
字母只有 26 种
不重复 ⇒ 长度 ≤ 26
所以 len 只需枚举 1 ~ 26
复杂度降到 O(26n)
⚠️ 易错点
枚举 len 到 i(O(n²) 超时)
用 int(价值可达 10¹⁴)
重复检测写错(忘了提前退出)
dp[0] 未初始化
a 的下标是"子串长度",所以 a₁=2、a₂=1、a₃=7…
1
dp[0] = 0
空串价值为 0
dp[0] = 0
2
dp[1](前缀 "s")
len = 1:子串 "s" 无重复 ✓
dp[1] = dp[0] + a₁ = 0 + 2 = 2
dp[1] = 2
3
dp[2](前缀 "st")
len = 1:"t" ✓ → dp[1] + a₁ = 2 + 2 = 4
len = 2:"st" ✓(s、t 不重复)→ dp[0] + a₂ = 0 + 1 = 1
取最大 → 4
dp[2] = 4
4
dp[3](前缀 "str")
len = 1:"r" ✓ → dp[2] + 2 = 6
len = 2:"tr" ✓ → dp[1] + 1 = 3
len = 3:"str" ✓ → dp[0] + a₃ = 7
取最大 → 7
dp[3] = 7
5
dp[4](前缀 "stre")—— 出现重复!
len = 1:"e" ✓ → dp[3] + 2 = 9
len = 2:"re" ✓ → dp[2] + 1 = 5
len = 3:"tre" ✓ → dp[1] + a₃ = 2 + 7 = 9
len = 4:"stre" ✓ → dp[0] + a₄ = 4
取最大 → 9
dp[4] = 9
6
dp[5](前缀 "stree")
len = 1:"e" ✓ → dp[4] + 2 = 11
len = 2:"ee" ✗ 出现重复,立即停止
所以不再考虑更长的 len(因为更长一定也含重复)
dp[5] = 11
dp[5] = 11
7
dp[6](完整串 "street")
len = 1:"t" ✓ → dp[5] + 2 = 13
len = 2:"et" ✓ → dp[4] + 1 = 10
len = 3:"eet" ✗ 停止
dp[6] = 13
✅ 答案 13
📊 dp 汇总
i0123456
前缀sststrstrestreestreet
dp[i]024791113
最优划分:str + e + e + t → 7 + 2 + 2 + 2 = 13 ✓
🔑注意 "e + e" 这两段:它们是两个独立的子串,各自都只有 1 个字母,所以允许重复字母出现在不同子串里。题目只要求"子串内不重复",不是整个划分后不能有相同字母。
🧮 样例 2:s = "blossoms",a = [1,1,2,3,5,8,13,21]
这组数据的价值随长度增长得很快(像斐波那契),但因为有 "ss" 的重复,长段常常不可用。
i前缀dp[i]最优最后一段
0(空)0—
1b1"b"(长度 1,价值 1)
2bl2"l"
3blo3"o"
4blos4"s"
5bloss5"s"("ss" 重复,不能取长度 2)
6blosso6"o"
7blossom7"m"
8blossoms8"s"
1
为什么 dp[5] 只能加长度 1?
前缀是 "bloss",最后两个字符是 "ss"
len = 1:"s" ✓ → dp[4] + a₁ = 4 + 1 = 5
len = 2:"ss" ✗ 重复 → 停止枚举
所以 dp[5] = 5
dp[5] = 5
2
为什么最终是 8?
看起来 a₄ = 3、a₅ = 5、a₈ = 21 都很诱人
但因为 "ss" 的存在,任何跨越这两个 s 的段都非法
所以只能一段一段切(每段长度 1)
总价值 = 1 × 8 = 8
✅ 答案 8
答案 8 ✓
⚠️这个样例很能说明"DP 必须老老实实枚举":a₈ = 21 看起来最大,但整个串 "blossoms" 含重复的 s,不能作为一整段。如果只贪心地"尽量取长段",就会出错。dp 的 max 会把所有合法长度都考虑进去。
🟢 利用"长度 ≤ 26"优化(推荐) 推荐
枚举最后一段长度时,一旦出现重复字母就立即停止
时间 O(26n) ≈ 2.6 × 10⁶
n = 10⁵ 时轻松通过
代码 25 行
空间 O(n)
💡内层循环的写法:从 i 往前逐字符走,用 cnt[字符] 计数;一旦 cnt > 1 就 break。由于字母只有 26 种,这个循环最多跑 26 次。
🟠 朴素 O(n²) DP
对每个 i 枚举所有可能长度,用前缀和判断合法性
时间 O(n²) = 10¹⁰
必然超时
只能通过 40% 的小数据
逻辑正确但太慢
⚠️关键差距:朴素做法忽略了"合法段长度天然 ≤ 26"这个事实,白白枚举了大量不可能的长度。竞赛中"从题目条件里抠出隐含上界"往往能把复杂度降一个量级。
📈 性能对比
方案运算量(n = 10⁵)可行性
长度≤26 优化约 2.6 × 10⁶✅ 稳过
朴素 O(n²) DP约 10¹⁰❌ 超时
第一行输入字符串,第二行输入各长度的价值,程序会算出最大价值并展示 dp。
输入数据street
2 1 7 4 3 3
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[100005], dp[100005];
char s[100005];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1); // 1-based,方便用 dp[i] 表示"前 i 个字符"
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int cnt[26] = {0}; // 本次枚举的字符计数
long long best = -1;
// 从后往前扩展最后一段,长度最多 26
for (int len = 1; len <= i && len <= 26; len++) {
int c = s[i - len + 1] - 'a';
cnt[c]++;
if (cnt[c] > 1) break; // 出现重复,后面的更长段一定也不合法
best = max(best, dp[i - len] + a[len]);
}
dp[i] = best;
}
printf("%lld\n", dp[n]);
return 0;
}
🔑为什么"出现重复就可以 break"?因为我们是从短的段往长的段扩展的:如果长度 len 的这一段已经含重复字母,那么长度 len+1 的段(在它前面再加一个字符)必然也含重复。所以后面的都不必再试。这个"单调性"正是循环能提前退出的依据,也是复杂度能降到 O(26n) 的关键。
另外注意 dp[0] = 0 必须初始化,它对应"整段就是一个子串"的情形。
📖 关键几行怎么看
代码作用为什么这样写
cnt[26] = {0}字符计数每个 i 都重新清空
len <= 26长度上界字母只有 26 种,不重复则长度 ≤ 26
if (cnt[c] > 1) break;合法性判断单调性:出现重复后更长段也必然重复
dp[i - len] + a[len]转移最后一段 + 之前的最优
long long类型价值可达 10¹⁴
⚠️四个坑:① 内层枚举到 i(O(n²) 超时,忘了长度 ≤ 26);② 用 int(n × aᵢ 可达 10¹⁴);③ 出现重复后没 break(虽然结果仍对,但复杂度退化);④ 忘了 dp[0] = 0 的初始化。
写完程序后,用这些数据自查一遍:
输入答案考察点
6
street
2 1 7 4 3 313题面样例 1:str + e + e + t
8
blossoms
1 1 2 3 5 8 13 218题面样例 2(含 "ss" 重复)
1
a
55单字符
3
abc
1 10 100100整串合法,取长度 3
3
aaa
1 10 1003只能切成三个单字符:1+1+1 = 3
2
aa
100 100200重复字母必须切分
✅自查清单:① 内层限制 len ≤ 26 吗?② 出现重复立即 break 吗?③ 用 long long 吗?
🚨 易错点清单
⚠️枚举所有长度:合法的段长天然 ≤ 26,不利用这点会退化成 O(n²)。
⚠️用 int:价值可达 10¹⁴,需要 long long。
⚠️初始值错:dp[0] 必须为 0,且内层 best 初值要足够小(用 -1 即可,因为价值非负)。
时间复杂度
O(26n)
空间复杂度
O(n)
运算量
约 2.6 × 10⁶
关键
合法段长度 ≤ 26
时间怎么算的?
外层枚举 i:n 次
内层最多 26 次(字母种类数)
合计 ≤ 26n = 2.6 × 10⁶
若不做这个限制则是 O(n²) = 10¹⁰,会超时
空间都用在哪?
dp 数组 + 字符串 + 价值数组。
✅ 约 260 万次操作,瞬间完成。注意:若字母表变成 52 种(大小写),上限变成 52,依然是 O(52n)。
// 分割型 DP 的通用骨架
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int len = 1; len <= i && len <= 26; len++) {
if (!合法(i - len + 1, i)) break; // 一旦不合法就退出
dp[i] = max(dp[i], dp[i - len] + a[len]);
}
}
// 从题目条件里抠"隐含上界"的思路
// - 字母不重复 -> 长度 <= 26(字母种数)
// - 数值范围小 -> 状态可枚举
// - 答案单调 -> 可以二分
// 这些"隐含上界"往往就是复杂度的突破口
// 类似题目
// - 把数组分成若干段使代价最小/最大
// - 每段有长度限制的分段问题
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
分割型 DPdp[i] 枚举最后一段切分字符串/数组的所有分段问题
隐含上界字母不重复 ⇒ len ≤ 26利用题目条件降复杂度
单调性 break不合法后更长段必不合法双指针、滑动窗口类优化
🌟思考题:如果题目把"小写字母"改成"至多 10 种字符",复杂度会变吗?(提示:会变,而且是变快——内层枚举上限从 26 降到 10,复杂度变成 O(10n)。这说明"字母表的种类数"直接决定内层循环的长度,所以看到"字符不重复"就要立刻想到"段长受限于字符种类数"。)
#include <bits/stdc++.h>
using namespace std;
long long a[100005], dp[100005];
char s[100005];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1); // 1-based,方便用 dp[i] 表示"前 i 个字符"
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int cnt[26] = {0}; // 本次枚举的字符计数
long long best = -1;
// 从后往前扩展最后一段,长度最多 26
for (int len = 1; len <= i && len <= 26; len++) {
int c = s[i - len + 1] - 'a';
cnt[c]++;
if (cnt[c] > 1) break; // 出现重复,后面的更长段一定也不合法
best = max(best, dp[i - len] + a[len]);
}
dp[i] = best;
}
printf("%lld\n", dp[n]);
return 0;
}// 分割型 DP 的通用骨架
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int len = 1; len <= i && len <= 26; len++) {
if (!合法(i - len + 1, i)) break; // 一旦不合法就退出
dp[i] = max(dp[i], dp[i - len] + a[len]);
}
}
// 从题目条件里抠"隐含上界"的思路
// - 字母不重复 -> 长度 <= 26(字母种数)
// - 数值范围小 -> 状态可枚举
// - 答案单调 -> 可以二分
// 这些"隐含上界"往往就是复杂度的突破口
// 类似题目
// - 把数组分成若干段使代价最小/最大
// - 每段有长度限制的分段问题- 1≤q p_i≤q n(1≤q i≤q k);
- p_{i+1}≥q p_i+b_{p_i}(1≤q i< k)。
你需要在满足以上条件的前提下最大化 Σ_{i=1}^k a_{p_i},也即最大化数组 a 对应下标的整数之和。
第二行,n 个正整数 a_1,a_2,…,a_n,表示数组 a。
第三行,n 个正整数 b_1,b_2,…,b_n,表示数组 b。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 2 3 4 3 3 1 1 | 7 |
| 2 | 6 1 1 4 5 1 4 1 2 3 2 1 0 | 11 |
对于所有测试点,保证 2≤q n≤q 10^5,0≤q a_i≤q 10^9,0≤q b_i≤q n。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定两个长度为 n 的数组 a、b。要选出下标 p₁ < p₂ < … < p_k,满足:
1 ≤ p_i ≤ n
p_(i+1) ≥ p_i + b_(p_i)——下一个下标必须"跳过"至少 b 个位置
在此前提下最大化 Σ a_(p_i)。
💡人话翻译:这是一道典型的"选或不选"的线性 DP。设 dp[i] 表示"选了下标 i,且之后继续选下去能得到的最大和"。
那么 dp[i] = a[i] + (从 i + b[i] 之后最大的 dp)。用一个后缀最大值数组把"之后最大的 dp"做成 O(1) 查询。
🔍 关键词提取
线性 DP后缀最大值状态定义O(n) 递推
已知条件
项目说明
输入第一行 n;第二行 a₁…aₙ;第三行 b₁…bₙ
输出所选 a 之和的最大值
数据范围2 ≤ n ≤ 10⁵
a 的范围0 ≤ aᵢ ≤ 10⁹
b 的范围0 ≤ bᵢ ≤ n
需要解决的问题
状态怎么定义?关键是让"下一个位置"可描述:定义 dp[i] = 从 i 出发(必须选 i)能取到的最大和
转移怎么写?dp[i] = a[i] + max(0, max{dp[j] : j ≥ i + b[i], j > i})
为什么需要 j > i?因为下标必须严格递增;b[i] = 0 时只靠 i + b[i] = i 不能保证递增
怎么做到 O(n)?从右往左算,并维护 suf[i] = max(dp[i], dp[i+1], …, dp[n])
🧠 状态定义
dp[i]:必选 i 时的最大和
答案 = max 所有 dp[i]
转移只依赖更大的下标
所以可从右往左推
🔁 转移
下一个位置 j 需满足 j ≥ i + b[i]
且必须 j > i(严格递增)
所以 j ≥ max(i+1, i+b[i])
dp[i] = a[i] + 该范围内最大 dp
⚡ 加速
朴素转移是 O(n²)
维护后缀最大值 suf
suf[t] = max(dp[t..n])
查询变 O(1)
⚠️ 易错点
漏掉 j > i 导致 b[i]=0 时死循环
忘记可以和 0 取 max(后面一个都不选)
用 int(Σa 可达 10¹⁴)
答案没取全局最大值
从右往左推。这里 suf[t] 表示 max(dp[t..n]),超出 n 时取 0。
1
i = 4
需要 j ≥ max(5, 4+1) = 5 → 没有可用位置
dp[4] = a[4] + 0 = 4
suf[4] = 4
dp[4] = 4
2
i = 3
b[3] = 1 → 需要 j ≥ max(4, 4) = 4
suf[4] = dp[4] = 4
dp[3] = a[3] + 4 = 3 + 4 = 7
suf[3] = max(dp[3], suf[4]) = max(7, 4) = 7
dp[3] = 7
3
i = 2
b[2] = 3 → 需要 j ≥ max(3, 5) = 5 → 无可用位置
dp[2] = a[2] + 0 = 2
suf[2] = max(2, 7) = 7
dp[2] = 2
4
i = 1
b[1] = 3 → 需要 j ≥ max(2, 4) = 4
suf[4] = 4
dp[1] = a[1] + 4 = 1 + 4 = 5
suf[1] = max(5, 7) = 7
dp[1] = 5
ia[i]b[i]j 的下界用到的 sufdp[i]
4415(越界)04
3314suf[4] = 47
2235(越界)02
1134suf[4] = 45
答案 = max(dp) = 7 ✓(选下标 3、4:3 + 4 = 7)
🧮 样例 2:a = [1,1,4,5,1,4],b = [1,2,3,2,1,0]
这次要留意 b[6] = 0 的边界。
1
i = 6(b[6] = 0 的关键案例)
b[6] = 0 → 单纯看 i + b[i] = 6,但下标必须严格递增
所以 j 的下界是 max(6+1, 6+0) = 7
没有可用位置 → dp[6] = a[6] = 4
如果忘了 j > i 这个条件,就会错误地允许再选一次 6(同一个下标),逻辑就崩了
dp[6] = 4
2
i = 5、4、3
i = 5:下界 max(6, 6) = 6 → suf[6] = 4 → dp[5] = 1 + 4 = 5
i = 4:下界 max(5, 6) = 6 → 4 → dp[4] = 5 + 4 = 9
i = 3:下界 max(4, 6) = 6 → 4 → dp[3] = 4 + 4 = 8
suf 更新:suf[5] = max(5,4) = 5;suf[4] = max(9,5) = 9;suf[3] = 9
dp = [?, ?, 8, 9, 5, 4]
3
i = 2、1
i = 2:下界 max(3, 4) = 4 → suf[4] = 9 → dp[2] = 1 + 9 = 10
i = 1:下界 max(2, 2) = 2 → suf[2] = max(10,9,5,4) = 10
→ dp[1] = 1 + 10 = 11
suf[1] = max(11, 10, 9, 5, 4) = 11
答案 11
i123456
dp[i]11108954
答案 = max(dp) = 11 ✓(选 1、2、4:1 + 1 + 5 = 7?)
🔑找一组能达到 11 的方案:选下标 1、2、4、6:a₁ + a₂ + a₄ + a₆ = 1 + 1 + 5 + 4 = 11 ✓
验证约束:p₂ = 2 ≥ p₁ + b₁ = 1 + 1 = 2 ✓;p₃ = 4 ≥ p₂ + b₂ = 2 + 2 = 4 ✓;p₄ = 6 ≥ p₄ … 即 6 ≥ p₃ + b₄ = 4 + 2 = 6 ✓。完全满足条件。
🟢 线性 DP + 后缀最大值(推荐) 推荐
从右往左算 dp[i],用 suf 数组 O(1) 查询后续最大 dp
时间 O(n)
n = 10⁵ 时约 10⁵ 次
代码 20 行
空间 O(n)(可滚动数组优化)
💡核心两行:dp[i] = a[i] + suf[max(i+1, i+b[i])];suf[i] = max(dp[i], suf[i+1]);注意 max(i+1, …) 里的 i+1 不能省(保证下标严格递增)。
🟠 枚举所有子集或所有下标组合
枚举所有合法的下标序列,取最大和
可能的序列数量指数级
n = 10⁵ 完全不可行
只能处理 n ≤ 20 左右
完全不适合
⚠️注意:本题的"选择"有顺序依赖(选了下标 i 就限定了下一个可以选的范围),这正是 DP 的典型特征。看到"选出一组满足位置约束的下标、使和最大",就该往 DP 想。
📈 性能对比
方案复杂度(n = 10⁵)可行性
线性 DP约 10⁵✅ 瞬间
枚举组合指数级❌ 不可行
第一行输入 a,第二行输入 b,程序会从右往左推出 dp 并给出答案。
输入数据1 2 3 4
3 3 1 1
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[100005], dp[100005], suf[100005];
int b[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
suf[n + 1] = 0; // 越界时最大值为 0(后面一个都不选)
for (int i = n; i >= 1; i--) {
// 下一个可选位置:既要跳够 b[i],又要严格大于 i
int t = max(i + 1, i + b[i]);
long long best = (t <= n) ? suf[t] : 0;
dp[i] = a[i] + best;
suf[i] = max(dp[i], suf[i + 1]);
}
printf("%lld\n", suf[1]); // suf[1] 就是所有 dp 的最大值
return 0;
}
🔑为什么 t = max(i + 1, i + b[i]) 里的 i + 1 不能省?当 b[i] = 0 时,i + b[i] = i,意思是"下一个下标 ≥ i"。但题目要求下标严格递增(p₁ < p₂ < …),所以至少要 i + 1。漏掉这个条件会允许"同一个下标被重复选用",逻辑就错了。
📖 关键几行怎么看
代码作用为什么这样写
suf[n+1] = 0哨兵越界时表示"后面不选任何数"
t = max(i + 1, i + b[i])下一个位置的下界兼顾"严格递增"和"跳够 b[i]"
dp[i] = a[i] + suf[t]转移必选 i,再加上后续最优
suf[i] = max(dp[i], suf[i+1])后缀最大值让查询 O(1)
printf("%lld", suf[1])输出suf[1] = max(dp[1..n])
⚠️四个坑:① 忘记 max 里的 i + 1;② 用 int(Σa 可达 10⁵ × 10⁹ = 10¹⁴,必须 long long);③ 转移时忘了"可以和 0 取 max"(即后面一个都不选,用哨兵 suf[n+1] = 0 自然处理);④ 输出写成 dp[1](应该是 suf[1],因为最优解不一定从下标 1 开始)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
1 2 3 4
3 3 1 17题面样例 1(选 3、4)
6
1 1 4 5 1 4
1 2 3 2 1 011题面样例 2(选 1、2、4、6)
2
5 7
1 012b₁=1 允许选到 2,两个都能选
2
5 7
2 07b₁=2 时从 1 跳不到 2,只能选一个
3
0 0 0
0 0 00全是 0,答案 0
5
9 1 1 1 9
4 0 0 0 018b₁=4 允许从 1 直接跳到 5,取 9 + 9 = 18
✅自查清单:① 写了 max(i+1, …) 吗?② 用 long long 吗?③ 输出 suf[1] 吗?
🚨 易错点清单
⚠️漏掉 i + 1:b[i] = 0 时下标可能不递增,必须用 max(i+1, i+b[i])。
⚠️用 int:aᵢ ≤ 10⁹、n ≤ 10⁵,总和可达 10¹⁴,必须 long long。
⚠️输出 dp[1]:最优解不一定从下标 1 开始,应输出 suf[1]。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
运算量
约 10⁵
时间怎么算的?
倒序循环 n 次
每次 O(1)(含一次 max 查询)
合计 O(n)
空间都用在哪?
数组 a、b、dp、suf 各 O(n)。实际上可以只保留 suf,把空间降到 O(n) 常数级(滚动)。
✅ 约 10 万次运算,瞬间完成。关键是"从右往左推 + 后缀最大值"这个组合。
// 本题的 DP 骨架
suf[n + 1] = 0;
for (int i = n; i >= 1; i--) {
int t = max(i + 1, i + b[i]);
dp[i] = a[i] + (t <= n ? suf[t] : 0);
suf[i] = max(dp[i], suf[i + 1]);
}
// 答案 = suf[1]
// 类似"选一批满足位置约束的下标"的题都可以这样设计状态
// 关键点:让"下一个位置的范围"能被当前状态确定
// 后缀最大值 / 前缀最大值 是 DP 优化的常用手段
// 把 O(n) 的区间查询压成 O(1)
for (int i = n; i >= 1; i--) suf[i] = max(a[i], suf[i + 1]); // 后缀最大
for (int i = 1; i <= n; i++) pre[i] = max(a[i], pre[i - 1]); // 前缀最大
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
线性 DP状态 + 转移 + 边界所有"选/不选"的序列问题
后缀最大值O(1) 查询区间最值所有转移需要"后续最优"的 DP
严格递增约束max(i+1, …)下标/位置必须递增的题
🌟思考题:如果约束改成"p_(i+1) ≥ p_i + b_(p_i) 且还要 a_(p_i) ≥ a_(p_(i+1))"(选出的 a 值单调不增),上面的 DP 还成立吗?(提示:不再直接成立——因为转移时"能不能选 j"不仅取决于位置,还取决于"上一个选的 a 值",需要把状态扩展成 dp[i][值] 或用其他数据结构优化。约束一旦和"值"挂钩,状态空间就会膨胀。)
#include <bits/stdc++.h>
using namespace std;
long long a[100005], dp[100005], suf[100005];
int b[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
suf[n + 1] = 0; // 越界时最大值为 0(后面一个都不选)
for (int i = n; i >= 1; i--) {
// 下一个可选位置:既要跳够 b[i],又要严格大于 i
int t = max(i + 1, i + b[i]);
long long best = (t <= n) ? suf[t] : 0;
dp[i] = a[i] + best;
suf[i] = max(dp[i], suf[i + 1]);
}
printf("%lld\n", suf[1]); // suf[1] 就是所有 dp 的最大值
return 0;
}// 本题的 DP 骨架
suf[n + 1] = 0;
for (int i = n; i >= 1; i--) {
int t = max(i + 1, i + b[i]);
dp[i] = a[i] + (t <= n ? suf[t] : 0);
suf[i] = max(dp[i], suf[i + 1]);
}
// 答案 = suf[1]
// 类似"选一批满足位置约束的下标"的题都可以这样设计状态
// 关键点:让"下一个位置的范围"能被当前状态确定
// 后缀最大值 / 前缀最大值 是 DP 优化的常用手段
// 把 O(n) 的区间查询压成 O(1)
for (int i = n; i >= 1; i--) suf[i] = max(a[i], suf[i + 1]); // 后缀最大
for (int i = 1; i <= n; i++) pre[i] = max(a[i], pre[i - 1]); // 前缀最大你需要将数组 A 划分为若干非空连续子段。对于划分得到的某个子段,它的偏差值定义为子段内整数和的平方。划分方案的偏差值定义为所有子段偏差值之和。
你需要最小化划分方案的偏差值。
形式化地,你可以将 A 划分为若干非空连续子段 A_1,A_2,…,A_k,使得 A=A_1+A_2+…+A_k,这里的 + 代表数组的连接。对于 1≤ i≤ k,设数组 A_i=[a_1^{(i)},…,a_{m_i}^{(i)}] 包含 m_i 个整数。你需要最小化 Σ_{i=1}^{k}≤ft(Σ_{j=1}^{m_i}a_j^{(i)})^2。
第二行,n 个整数 a_1,a_2,…,a_n,表示数组 A。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 2 -3 4 | 6 |
| 2 | 6 -1 -1 4 -5 -1 4 | 0 |
对于所有测试点,保证 1≤ n≤ 2000,-100≤ a_i≤ 100。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
把数组 A 划分为若干非空连续子段。一个子段的偏差值是段内元素和的平方;整个划分的偏差值是各段偏差值之和。求最小的偏差值。
💡人话翻译:标准的"分段型 DP"。设 dp[i] = 前 i 个数划分后的最小偏差值。
枚举最后一段的起点 j:dp[i] = min(dp[j] + (pre[i] − pre[j])²),其中 pre 是前缀和。
n ≤ 2000,O(n²) = 4 × 10⁶,完全可行。
🔍 关键词提取
分段型 DP前缀和平方偏差O(n²)
已知条件
项目说明
输入第一行 n;第二行 n 个整数 aᵢ
输出最小偏差值
数据范围1 ≤ n ≤ 2000
数值范围−100 ≤ aᵢ ≤ 100
段的性质非空、连续
需要解决的问题
状态怎么设?dp[i]:前 i 个数的最小偏差值,dp[0] = 0
转移怎么写?枚举最后一段 [j+1, i]:dp[i] = min(dp[j] + (pre[i] − pre[j])²)
为什么可以用前缀和?段和 = pre[i] − pre[j],O(1) 求出
🧠 状态
dp[i]:前 i 个数的最小偏差
dp[0] = 0
答案 = dp[n]
按前缀长度递推
🔁 转移
枚举最后一段起点 j(0 ≤ j < i)
段和 = pre[i] − pre[j]
代价 = 段和的平方
dp[i] = min(dp[j] + 代价)
📐 为什么"段和"要平方
平方对大段惩罚更重
所以倾向拆细
但负数会让"拆细"不一定最优
必须 DP 枚举
⚠️ 易错点
段和用 int(可达 2000 × 100 = 2 × 10⁵,平方后 4 × 10¹⁰)
j 的枚举范围写错
忘记 dp[0] = 0
把"连续"理解成"任意"
先算前缀和:0、1、3、0、4。
划分方案各段和偏差值
[1 2 −3 4]416
[1 2 −3][4]0, 40 + 16 = 16
[1][2 −3 4]1, 31 + 9 = 10
[1 2][−3 4]3, 19 + 1 = 10
[1][2][−3 4]1, 2, 11 + 4 + 1 = 6
[1][2][−3][4]1, 2, −3, 41 + 4 + 9 + 16 = 30
最小偏差值 6 ✓
1
DP 逐步计算
dp[0] = 0
dp[1] = dp[0] + (1)² = 1
dp[2] = min(dp[1] + (2)², dp[0] + (3)²) = min(5, 9) = 5
dp[3] = min(dp[2] + (−3)², dp[1] + (−2)², dp[0] + 0²)
= min(5 + 9, 1 + 4, 0) = min(14, 5, 0) = 0
dp[4] = min(dp[3] + 4², dp[2] + 1², dp[1] + 3², dp[0] + 4²)
= min(16, 6, 10, 16) = 6
✅ dp[4] = 6
🔑注意 dp[3] = 0 这一步:前三项 1 + 2 + (−3) = 0,整段作为一段的偏差是 0² = 0——这是"负数让段和归零"的典型情形。
然后 dp[4] 从 dp[2] + 1² = 5 + 1 = 6 得到,对应划分 [1][2][−3 4]。
🧮 样例 2:A = [−1, −1, 4, −5, −1, 4],答案 0
这组数据的总和恰好是 0,所以"整段不切"就能拿到 0 分。
1
验证总和
(−1) + (−1) + 4 + (−5) + (−1) + 4
= −1 − 1 + 4 − 5 − 1 + 4
= 0
所以整段偏差 = 0² = 0
✅ 答案 0
2
DP 也会得到 0
dp[6] 会考虑 j = 0 的情况
即整段作为最后一段:dp[0] + (pre[6] − pre[0])² = 0
而偏差值不可能为负(平方和 ≥ 0)
所以 0 就是最小值
✅ 下界达到
📊 一个重要观察
因为偏差值是平方和,所以永远 ≥ 0。因此一旦能凑出"所有段和都为 0",就得到了理论最小值 0。
⚠️但不要因此就写"贪心拆零":本题数据里有负数,"段和为零"未必能通过简单的贪心达成,而且一般情况下最优解也不是"全拆成零和段"。
老老实实写 O(n²) 的 DP 最稳妥——n ≤ 2000 的规模就是为 O(n²) 设计的。
🟢 区间划分 DP(推荐) 推荐
dp[i] 枚举最后一段起点 j,用前缀和 O(1) 取段和
时间 O(n²) = 4 × 10⁶
代码 12 行
空间 O(n)
对负数同样正确
💡核心两行:for (j = 0; j < i; j++) dp[i] = min(dp[i], dp[j] + (pre[i]-pre[j])*(pre[i]-pre[j]));注意用 long long,因为段和的平方可达 4 × 10¹⁰。
🟠 贪心:遇到某处就切
按"段和尽量接近 0"之类规则贪心切分
看起来合理
但有反例(负数的存在使局部最优≠全局最优)
无正确性保证
不建议
⚠️为什么不能贪心:平方函数是凸的,"拆细"和"合并"的收益取决于两侧的具体数值,不能只靠局部判断。
例如样例 1 里 1+2+(−3) = 0,合起来不花代价,但如果贪心一路拆开反而更贵(30 > 6)。
📈 性能对比
方案复杂度正确性
划分 DPO(n²)✅ 最优
贪心切分O(n)❌ 有反例
输入数组,程序会算出最小偏差值并给出最优划分方案。
输入数组
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[2005], pre[2005], dp[2005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pre[i] = pre[i - 1] + a[i]; // 前缀和
}
for (int i = 1; i <= n; i++) dp[i] = (long long)4e18;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) { // 枚举最后一段 [j+1, i]
long long seg = pre[i] - pre[j]; // 该段之和
dp[i] = min(dp[i], dp[j] + seg * seg);
}
}
printf("%lld\n", dp[n]);
return 0;
}
🔑为什么必须用 long long?段和最大约 2000 × 100 = 2 × 10⁵,平方后是 4 × 10¹⁰——远超 int 上限(约 2.1 × 10⁹)。
而总偏差值还要把多段相加,所以必须用 64 位整数。这是本题最容易"看起来对但过不了"的地方。
📖 关键几行怎么看
代码作用为什么这样写
pre[i] = pre[i-1] + a[i]前缀和让段和 O(1) 求出
for (j = 0; j < i; j++)枚举起点最后一段是 [j+1, i]
seg = pre[i] - pre[j]段和前缀和之差
dp[j] + seg * seg转移前缀最优 + 最后一段偏差
long long类型seg² 可达 4 × 10¹⁰
⚠️四个坑:① 用 int(平方会溢出);② j 的枚举范围写成 1 ≤ j < i(会漏掉"整段从第 1 个开始"的情形,必须允许 j = 0);③ 忘记 dp[0] = 0;④ dp 初值设太小(应设成很大的数,如 4e18)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
1 2 -3 46题面样例 1:最优为 [1][2][−3 4]
6
-1 -1 4 -5 -1 40题面样例 2(总和为 0,整段不切即 0)
1
525只有一个数,只能作为一段
2
3 -30整段和为 0
3
0 0 00全为 0,怎么切都是 0
✅自查清单:① 用 long long 吗?② j 从 0 开始吗?③ dp[0] = 0 吗?
🚨 易错点清单
⚠️用 int:段和平方可达 4 × 10¹⁰,必须 long long。
⚠️j 从 1 开始:必须允许 j = 0(整段作为最后一段)。
⚠️贪心切分:有负数时贪心不保证最优。
时间复杂度
O(n²)
空间复杂度
O(n)
n 最大
2000
运算量
约 2 × 10⁶
时间怎么算的?
外层 i 共 n 次
内层 j 共 i 次
合计 n(n+1)/2 ≈ 2 × 10⁶
空间都用在哪?
数组 a、前缀和 pre、dp 各 O(n)。
✅ 约 200 万次操作,瞬间完成。n ≤ 2000 的范围正是为 O(n²) 的划分 DP 设计的。
// 分段型 DP 的通用骨架
dp[0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < i; j++) // 枚举最后一段 [j+1, i]
dp[i] = min(dp[i], dp[j] + cost(j + 1, i));
// 答案 = dp[n]
// 本题的 cost 就是段和的平方,借助前缀和 O(1) 求出
// 同类问题
// - 每段代价 = 段和(绝对值):贪心恰好可行
// - 每段代价 = 段和²:需要 DP(本题)
// - 每段代价 = 段长的平方:也需 DP
// - 每段代价 = (段和 - 目标)²:斜率优化 DP(进阶)
// 若 n 放大到 10^5,就需要"四边形不等式优化"或"斜率优化"
// 把 O(n^2) 降到 O(n log n) 或 O(n)
// 那是更高等级的内容,本题不需要
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
分段型 DPdp[i] 枚举最后一段所有"切分序列"的最优化问题
前缀和O(1) 求段和区间求和的标准工具
平方代价对长段惩罚更重凸代价型问题(可用斜率优化)
🌟思考题:如果题目改成"每段代价是段和的绝对值"(即 |段和|),最优解会变简单吗?(提示:会简单很多——因为绝对值满足三角不等式,把相邻两段合并不会让代价变大,所以"尽量少切"往往最优,可以贪心甚至直接判断。代价函数的性质(凸性、三角不等式)直接决定了能不能用贪心。)
#include <bits/stdc++.h>
using namespace std;
long long a[2005], pre[2005], dp[2005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pre[i] = pre[i - 1] + a[i]; // 前缀和
}
for (int i = 1; i <= n; i++) dp[i] = (long long)4e18;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) { // 枚举最后一段 [j+1, i]
long long seg = pre[i] - pre[j]; // 该段之和
dp[i] = min(dp[i], dp[j] + seg * seg);
}
}
printf("%lld\n", dp[n]);
return 0;
}// 分段型 DP 的通用骨架
dp[0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < i; j++) // 枚举最后一段 [j+1, i]
dp[i] = min(dp[i], dp[j] + cost(j + 1, i));
// 答案 = dp[n]
// 本题的 cost 就是段和的平方,借助前缀和 O(1) 求出
// 同类问题
// - 每段代价 = 段和(绝对值):贪心恰好可行
// - 每段代价 = 段和²:需要 DP(本题)
// - 每段代价 = 段长的平方:也需 DP
// - 每段代价 = (段和 - 目标)²:斜率优化 DP(进阶)
// 若 n 放大到 10^5,就需要"四边形不等式优化"或"斜率优化"
// 把 O(n^2) 降到 O(n log n) 或 O(n)
// 那是更高等级的内容,本题不需要给定一串长度为 L、由数字 0\sim 9 组成的数字串 S。容易知道,它的连续子串共有 \frac{L(L + 1)}2 个。如果某个子串对应的数(允许有前导零)是 p 的倍数,则称该子串为数字串 S 对于 p 的亲朋数。
例如,数字串 S 为“ 12342 ”、p 为 2,则在 15 个连续子串中,亲朋数有“ 12 ”、“ 1234 ”、“ 12342 ”、“ 2 ”、“ 234 ”、“ 2342 ”、“ 34 ”、“ 342 ”、“ 4 ”、“ 42 ”、“ 2 ”共 11 个。注意其中“ 2 ”出现了 2 次,但由于其在 S 中的位置不同,记为不同的亲朋数。
现在,告诉你数字串 S 和正整数 p ,你能计算出有多少个亲朋数吗?
输入的第二行,包含一个长为 L 的数字串 S。约定 1 ≤q L ≤q 10^6。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 102 | 5 |
| 2 | 2 12342 | 11 |
5 个亲朋数,分别 10、102、0、02、2。
写完后可到洛谷
P10262 对照题解。②编程打卡 · 点一下就能勾选
- 完成 P10108《闯关游戏》,跑通全部样例
- 完成 P10376《游戏》,跑通全部样例
- 完成 P10250《下楼梯》,跑通全部样例
- 完成 P11963《环线》,跑通全部样例
- 完成 P14075《划分字符串》,跑通全部样例
- 完成 P15800《选数》,跑通全部样例
- 完成 P17457《数组划分》,跑通全部样例
- 完成 P10262《亲朋数》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
背包 DP
①本日知识点 · 背包 DP
0/1 背包容量倒序、完全背包正序;这是最容易写反的一处。
本组 6 道题全部来自 GESP 真题,按「背包 DP」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
编程计算总和为 n 的完全平方数的最小数量。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 18 | 2 |
对全部的测试数据,保证 1 ≤q n ≤q 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定正整数 n,把它拆成若干个完全平方数之和(允许重复),求所需平方数的最少数量。
例:18 = 9 + 9 = 3² + 3²,所以答案是 2。
💡人话翻译:本质上是一道完全背包——"物品"是所有不超过 n 的平方数 1, 4, 9, 16, …,每个物品可以重复使用,要"凑出恰好 n"且用最少的件数。
定义 dp[i] = 凑出 i 所需的最少平方数个数,则 dp[i] = 1 + min(dp[i − s])(s 为不超过 i 的平方数)。
另外还有一个漂亮的数学结论:答案只可能是 1、2、3、4。
🔍 关键词提取
完全背包完全平方数四平方和定理最小值 DP
已知条件
项目说明
输入一个正整数 n
输出最少需要的完全平方数个数
数据范围1 ≤ n ≤ 10⁵
约束拆出的数必须是完全平方数,可重复
目标数量最少
需要解决的问题
状态怎么设?dp[i] = 凑出 i 的最少个数,dp[0] = 0
转移怎么写?枚举最后一个平方数 s:dp[i] = min(dp[i − s] + 1)
为什么可以用定理加速?由拉格朗日四平方和定理,任何正整数都能写成 1~4 个平方数之和,所以答案 ≤ 4;再结合"是否是完全平方数""能否拆成两个平方数",就能 O(√n) 判定
🧠 状态定义
dp[i]:凑出 i 的最少个数
dp[0] = 0
答案是 dp[n]
按 i 递增递推
🔁 转移
枚举最后一个平方数 s
s 取 1、4、9、16…(≤ i)
dp[i] = min(dp[i−s] + 1)
平方数可重复使用
📐 数学视角
四平方和定理:答案 ≤ 4
是完全平方数 → 1
能拆成 a²+b² → 2
形如 4ᵏ(8m+7) → 4,否则 3
⚠️ 易错点
dp 初值设太大(应用 n 或 INF)
枚举平方数时越界
把"可重复"当成"只能用一次"
循环方向写错
先看能不能用 1 个:18 不是完全平方数(4²=16、5²=25)✗。再看 2 个:
拆分方式是否都是平方数结论
1 + 1717 不是 ✗—
4 + 1414 不是 ✗—
9 + 99 = 3² ✓✓✅ 可以!
16 + 22 不是 ✗—
18 = 3² + 3² → 答案 2 ✓
用 DP 也算一遍(枚举不超过 18 的平方数:1、4、9、16):
i可用拆分dp[i]
0—0
111
21 + 12
31 + 1 + 13
44(=2²)1
54 + 12
84 + 42
99(=3²)1
124 + 4 + 43
1616(=4²)1
1716 + 12
189 + 92
🔑注意 12 = 4+4+4 需要 3 个,而 16 只要 1 个。这说明"数值越大不一定越难拆"——关键看它离最近的平方数有多远。
DP 的正确性在于:它把"最后一个平方数是谁"的所有可能性都试了一遍,取最小值就一定最优。
🧮 数学方法的验证(4 个已知上界)
拉格朗日四平方和定理告诉我们答案只会是 1、2、3、4。下面用几个例子感受一下判定方法。
n判定过程答案
99 = 3²,是完全平方数1
18非平方数;18 = 9 + 9 ✓2
12非平方数;12 − 1 = 11 ✗、12 − 4 = 8 ✗、12 − 9 = 3 ✗(都不平方);12 = 4 × 3,3 % 8 = 3 ≠ 7 → 33
77 不是平方数;7−1=6 ✗、7−4=3 ✗;7 % 8 = 7 → 44
2828 = 4 × 7,7 % 8 = 7 → 44
100000是平方数?√100000 ≈ 316.2 ✗;100000 = 316² + 144 = 99856 + 144 ✓ → 22
1
判定 3 与 4 的依据
勒让德三平方和定理:
n 能写成三个平方数之和 ⟺ n 不形如 4ᵃ(8b + 7)
所以:先把 n 中的因子 4 全部除掉
若剩下部分 % 8 == 7 → 答案是 4
否则答案是 3(在已排除 1、2 的前提下)
O(√n) 判定
⚠️如果没把握记住定理,用 DP 更稳妥:DP 一定能算出正确答案,而数学方法需要记住"勒让德三平方和定理"的细节,写错一个余数条件就会全错。
所以:DP 是通用解法,定理是"锦上添花"。
🟢 完全背包式 DP(推荐) 推荐
dp[i] = 1 + min(dp[i − s]),s 遍历不超过 i 的平方数
时间 O(n√n) ≈ 3 × 10⁷
n = 10⁵ 时约 3000 万次
代码 15 行
不需要任何数论知识
💡实现细节:先预处理出所有 ≤ n 的平方数;外层 i 从 1 到 n,内层枚举平方数 s ≤ i,dp[i] = min(dp[i], dp[i−s] + 1)。注意平方数可以重复使用,所以这就是完全背包、不需要额外限制。
🟠 四平方和定理 O(√n)
用"答案 ∈ {1,2,3,4}"加判定条件直接得答案
时间 O(√n) ≈ 316
极快,代码 20 行
但需要掌握勒让德三平方和定理
条件写错就全错
⚠️适合什么场景:如果 n 达到 10¹⁸ 级别,DP 完全不可行,就只能用定理。本题 n ≤ 10⁵,DP 已经足够。
📈 性能对比
方案复杂度(n = 10⁵)依赖
完全背包 DP约 3 × 10⁷无(通用)
四平方和定理约 316需要数论知识
输入一个正整数 n,程序会算出最少需要几个完全平方数,并给出一种拆法。
输入 n
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int dp[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) dp[i] = n; // 初值取一个足够大的数
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int s = 1; s * s <= i; s++) {
dp[i] = min(dp[i], dp[i - s * s] + 1);
}
}
printf("%d\n", dp[n]);
return 0;
}
🔑为什么初值取 n 就够大?因为最坏情况是把 n 拆成 n 个 1(1 = 1²),所以答案一定 ≤ n。把初值设成 n 既能保证"一定被更新",又不会因为相加而溢出(如果用 INT_MAX,dp[i - s*s] + 1 就可能整数溢出)。
这是 DP 里一个很实用的小技巧:初值取"已知的可行上界"而不是"无穷大"。
📖 关键几行怎么看
代码作用为什么这样写
dp[i] = n初值最坏是 n 个 1,所以 n 是合法上界
dp[0] = 0边界凑出 0 不需要任何数
s * s <= i枚举范围平方数不能超过 i
dp[i - s*s] + 1转移用掉一个平方数 s²,件数加一
⚠️四个坑:① 初值用 INT_MAX 导致 +1 溢出;② 枚举平方数时写成 s <= i(越界且低效);③ 把"可重复使用"当成"每个平方数只能用一次";④ 忘了 dp[0] = 0。
写完程序后,用这些数据自查一遍:
输入答案考察点
182题面样例:9 + 9
111 = 1²
414 = 2²
1234 + 4 + 4
74需要 4 个:4 + 1 + 1 + 1
100000运行验证最大规模,注意效率
✅自查清单:① 初值安全吗?② 平方数枚举范围对吗?③ dp[0] = 0 吗?
🚨 易错点清单
⚠️初值溢出:用 INT_MAX 时 +1 会溢出,改用 n 作上界更安全。
⚠️平方数枚举越界:条件是 s * s <= i。
⚠️误解约束:平方数可以重复使用(12 = 4 + 4 + 4)。
时间复杂度
O(n√n)
空间复杂度
O(n)
运算量(n = 10⁵)
约 3 × 10⁷
数学解法
O(√n)
时间怎么算的?
外层 i 遍历 n 次
内层枚举平方数 ≤ √i 个
合计约 n × √n ≈ 3 × 10⁷
空间都用在哪?
一个长度 n + 1 的 dp 数组。
✅ 约 3000 万次运算,C++ 约 0.1 秒,可通过。若 n 更大(如 10¹⁸),就要用四平方和定理的 O(√n) 做法。
// 完全背包式 DP 骨架
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = 上界; // 取一个安全的初值
for (int s = 1; s * s <= i; s++)
dp[i] = min(dp[i], dp[i - s * s] + 1);
}
// 四平方和判定(O(sqrt(n)) 版本)
// 答案只可能是 1、2、3、4
int solveFast(int n) {
// 1. 是完全平方数 -> 1
int r = (int)(sqrt((double)n) + 0.5);
if (r * r == n) return 1;
// 2. 能拆成两个平方数之和 -> 2
for (int a = 1; a * a * 2 <= n; a++) {
int t = n - a * a;
int b = (int)(sqrt((double)t) + 0.5);
if (b * b == t) return 2;
}
// 3/4. 利用勒让德三平方和定理
while (n % 4 == 0) n /= 4;
if (n % 8 == 7) return 4;
return 3;
}
// 一些相关结论
// - 拉格朗日四平方和定理:任何正整数 = 至多 4 个平方数之和
// - 勒让德三平方和定理:n 需要 4 个 当且仅当 n = 4^a(8b+7)
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
完全背包物品可重复使用凑数、找零、最少件数问题
安全初值取已知上界而非 INT_MAX所有最小值 DP
四平方和定理答案 ∈ {1,2,3,4}大 n 时的数论加速
🌟思考题:如果题目改成"拆成若干个任意正整数之和,使它们的乘积最大",这题怎么做?(提示:完全不同了——那是最经典的"剪绳子"问题,答案是"尽量拆成 3"(余 1 时改成 2+2)。可见"约束"和"目标"一变,方法就从背包/数论变成了贪心。)
#include <bits/stdc++.h>
using namespace std;
int dp[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) dp[i] = n; // 初值取一个足够大的数
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int s = 1; s * s <= i; s++) {
dp[i] = min(dp[i], dp[i - s * s] + 1);
}
}
printf("%d\n", dp[n]);
return 0;
}// 完全背包式 DP 骨架
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = 上界; // 取一个安全的初值
for (int s = 1; s * s <= i; s++)
dp[i] = min(dp[i], dp[i - s * s] + 1);
}
// 四平方和判定(O(sqrt(n)) 版本)
// 答案只可能是 1、2、3、4
int solveFast(int n) {
// 1. 是完全平方数 -> 1
int r = (int)(sqrt((double)n) + 0.5);
if (r * r == n) return 1;
// 2. 能拆成两个平方数之和 -> 2
for (int a = 1; a * a * 2 <= n; a++) {
int t = n - a * a;
int b = (int)(sqrt((double)t) + 0.5);
if (b * b == t) return 2;
}
// 3/4. 利用勒让德三平方和定理
while (n % 4 == 0) n /= 4;
if (n % 8 == 7) return 4;
return 3;
}
// 一些相关结论
// - 拉格朗日四平方和定理:任何正整数 = 至多 4 个平方数之和
// - 勒让德三平方和定理:n 需要 4 个 当且仅当 n = 4^a(8b+7)班主任计划将班级里的 n 名同学划分为若干个学习小组,每名同学都需要分入某一个学习小组中。观察发现,如果一个学习小组中恰好包含 k 名同学,则该学习小组的讨论积极度为 a_k 。
给定讨论积极度 a_1, a_2, …, a_n ,请你计算将这 n 名同学划分为学习小组的所有可能方案中,讨论积极度之和的最大值。
第一行,一个正整数 n ,表示班级人数。
第二行, n 个非负整数 a_1, a_2, …, a_n ,表示不同人数学习小组的讨论积极度。
输出共一行,一个整数,表示所有划分方案中,学习小组讨论积极度之和的最大值。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 5 6 3 | 10 |
| 2 | 8 0 2 5 6 4 3 3 4 | 12 |
对于所有测试点,保证 1≤ n≤ 1000,0≤ a_i≤ 10^4。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
把 n 名同学划分成若干小组,每人必须属于某个组。若某个小组恰好 k 人,则该组积极度为 a_k。求所有划分方案中积极度之和的最大值。
💡人话翻译:典型的"整数划分"型 DP。设 dp[i] 表示"把 i 名同学分组能得到的最大积极度",转移就是枚举最后分出的一组有多少人:dp[i] = max(dp[i−k] + a_k)(k 从 1 到 i)。
注意每组人数没有上限,同一种组大小可以反复使用——所以这本质上是"完全背包"式的 DP。
🔍 关键词提取
整数划分分割型 DP完全背包枚举组大小
已知条件
项目说明
输入第一行 n;第二行 a₁…aₙ
输出最大积极度之和
数据范围1 ≤ n ≤ 1000
分值范围0 ≤ aᵢ ≤ 10⁴
约束每人属于恰好一个组;组大小可重复出现
需要解决的问题
状态怎么设?dp[i] = 把 i 个人分组的最大总分,dp[0] = 0
转移怎么写?枚举最后一组的人数 k:dp[i] = max(dp[i−k] + a[k]),k 遍历 1 ~ i
为什么 O(n²) 可以?n ≤ 1000,所以 n² = 10⁶,完全够快
🧠 状态定义
dp[i]:i 个人的最大总分
dp[0] = 0(0 人得 0 分)
答案 = dp[n]
按人数递推
🔁 转移
枚举最后一组的大小 k
k 从 1 遍历到 i
dp[i] = max(dp[i−k] + a[k])
取所有合法 k 的最大值
🔍 为什么是"完全背包"
组大小可重复使用
如 n=6 可分成 2+2+2
所以 k 可以反复选
与"完全背包"结构一致
⚠️ 易错点
dp 初值没设好(应为 0,因为分值非负)
用 int(总分可达 10⁷,仍在 int 内但保险用 long long)
枚举 k 时越界
把"组数上限"错加进去
a₁=1、a₂=5、a₃=6、a₄=3。
1
dp[0] = 0
0 个人不需要分组
dp[0] = 0
2
dp[1]
只能分成 1 人组:dp[0] + a₁ = 0 + 1 = 1
dp[1] = 1
3
dp[2]
k = 1:一个 1 人组 → dp[1] + a₁ = 1 + 1 = 2
k = 2:一个 2 人组 → dp[0] + a₂ = 0 + 5 = 5
取最大 → 5
dp[2] = 5
4
dp[3]
k = 1:dp[2] + a₁ = 5 + 1 = 6
k = 2:dp[1] + a₂ = 1 + 5 = 6
k = 3:dp[0] + a₃ = 0 + 6 = 6
三种都是 6
dp[3] = 6
5
dp[4]
k = 1:dp[3] + 1 = 7
k = 2:dp[2] + 5 = 5 + 5 = 10
k = 3:dp[1] + 6 = 1 + 6 = 7
k = 4:dp[0] + 3 = 3
取最大 → 10
✅ dp[4] = 10
📊 dp 汇总
i01234
dp[i]015610
最优方案—121+2 或 32+2
最优划分:2 + 2 → 5 + 5 = 10 ✓
🔑注意 "2 + 2" 里用了两次"2 人组"——这正是本题"组大小可重复"的体现。如果误以为是"每种组大小只能用一次"(0/1 背包),就会得到 2 + 1 + 1 = 7 这样的错误结果。读题时要抓住"每个小组恰好 k 人得 a_k 分",并没有说"组大小不能重复"。
🧮 样例 2:n = 8,a = [0, 2, 5, 6, 4, 3, 3, 4]
这组数据里 a₁ = 0,所以"单独成组"没有收益。
idp[i]最优最后一组大小说明
101a₁ = 0
222a₂ = 2
353a₃ = 5
464a₄ = 6
575max(dp[4]+0, dp[2]+a₃=2+5=7, a₅=4) = 7
6103 + 3dp[3] + a₃ = 5 + 5 = 10
7113 + 4dp[4] + a₃ = 6 + 5 = 11
8122 + 3 + 3dp[5] + a₃ = 7 + 5 = 12
答案 12 ✓
⚠️注意验证 dp[8]:我们算的是 dp[5] + a₃ = 7 + 5 = 12,即"先分 5 个人(最优 7 分),再补一个 3 人组(5 分)"。
而 dp[5] = dp[2] + a₃ = 2 + 5 = 7,所以整体是"2 + 3 + 3"三组,得分 2 + 5 + 5 = 12 ✓。这种"从子问题拼出来"的过程正是 DP 的精髓。
🟢 整数划分 DP(推荐) 推荐
dp[i] 枚举最后一组大小 k,dp[i] = max(dp[i−k] + a[k])
时间 O(n²) = 10⁶
n = 1000 时轻松通过
代码 12 行
空间 O(n)
💡为什么贪心不行:如果按"每组平均分最高"贪心,比如样例 1 里 a₄/4 = 0.75 而 a₂/2 = 2.5,但真正的最优还需要考虑能否整除——a_k 并不是线性的,所以只能老老实实 DP 枚举。
🟠 搜索所有分拆方案
枚举 n 的所有整数分拆,逐一计算得分
分拆数 p(1000) 天文数字
完全不可行
n = 10 时还行(40% 测试点)
不适合
⚠️量级对比:n = 1000 的整数分拆数 p(1000) 约为 2.4 × 10³¹——比宇宙原子数还多。而 DP 只需 10⁶ 次运算,这就是"用状态压缩掉重复子问题"的威力。
📈 性能对比
方案复杂度(n = 1000)可行性
整数划分 DP约 10⁶✅ 瞬间
枚举分拆指数/天文级❌ 不可行
第一行输入 n,第二行输入各规模小组的积极度,程序会算出最大总和。
输入数据4
1 5 6 3
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[1005], dp[1005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[0] = 0; // 0 个人得 0 分
for (int i = 1; i <= n; i++) {
long long best = 0;
for (int k = 1; k <= i; k++) { // 枚举"最后一组"的人数
best = max(best, dp[i - k] + a[k]);
}
dp[i] = best;
}
printf("%lld\n", dp[n]);
return 0;
}
🔑为什么 best 初值取 0 就够?因为题目保证 a_i ≥ 0,所以"分成若干组"的总分一定 ≥ 0。
如果 a_i 可能为负,初值就要设成很小的数(如 -1e18),并且要想清楚"是否允许不分组"(题目要求每人必须分组,所以不允许)。初值的选取要结合题意,不能照抄模板。
📖 关键几行怎么看
代码作用为什么这样写
dp[0] = 0边界0 个人的总分为 0
for (k = 1; k <= i; k++)枚举组大小最后一组可以是 1 ~ i 人中的任意大小
dp[i - k] + a[k]转移前 i−k 个人的最优 + 这一组的得分
best = max(best, ...)取最优在所有分法中选最大的
⚠️三个坑:① 误以为"每种组大小只能用一次"(那就变成 0/1 背包了);② 初值设成负无穷(本题分值非负,用 0 更简单);③ 循环边界写成 k < i(会漏掉"整组就是 i 人"的情形)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
1 5 6 310题面样例 1(2 + 2)
8
0 2 5 6 4 3 3 412题面样例 2(2 + 3 + 3)
1
77只分一组
3
0 0 00所有分值都是 0
6
1 1 1 1 1 16每种组都只值 1 分,分成 6 个单人组
6
0 0 0 0 0 100100整组 6 人最划算
✅自查清单:① 组大小可重复吗?② k 枚举到 i 吗?③ dp[0] = 0 吗?
🚨 易错点清单
⚠️组大小不可重复:题目没这个限制,同一种组大小可以反复出现(如样例 1 的 2 + 2)。
⚠️循环边界错:k 要遍历到 i(包含"整组 i 人")。
⚠️初值不当:分值非负时初值取 0 即可。
时间复杂度
O(n²)
空间复杂度
O(n)
n 最大
1000
运算量
约 5 × 10⁵
时间怎么算的?
外层 i 遍历 n 次
内层 k 遍历 i 次
合计 n(n+1)/2 ≈ 5 × 10⁵ 次
空间都用在哪?
dp 数组 + 价值数组,都是 O(n)。
✅ 约 50 万次运算,瞬间完成。若 n 放大到 10⁵,就需要更高级的优化(本题不需要)。
// 整数划分型 DP 的通用骨架
dp[0] = 0;
for (int i = 1; i <= n; i++)
for (int k = 1; k <= i; k++) // 枚举"最后一块"的大小
dp[i] = max(dp[i], dp[i - k] + a[k]);
// 与背包问题的对照
// - 本题:dp[i] 表示"凑出总量 i"的最优值,k 可重复使用 -> 完全背包
// - 若题目改成"每种组大小最多用一次" -> 0/1 背包(外层变成枚举物品)
// 差别只在"循环顺序"和"物品是否可重复"
// 完全背包(本题形式)
for (int i = 1; i <= n; i++)
for (int k = 1; k <= i; k++) dp[i] = max(dp[i], dp[i-k] + a[k]);
// 类似题目
// - 把 n 拆成若干正整数之和,使某种收益最大
// - 找零钱问题(硬币面额可重复使用)
// - 分段问题(每段长度有不同收益)
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
整数划分 DP枚举"最后一块"的大小所有"把 n 拆成若干份"的问题
完全背包物品可重复使用找零钱、分组、切分
0/1 vs 完全看循环顺序与物品是否可重复背包问题的关键区分点
🌟思考题:如果题目改成"每种组大小最多使用一次"(例如已经有 3 个组了就不能再建 3 人组),DP 要怎么改?(提示:那就变成0/1 背包了——需要增加一维"已经用了几个组",或者把物品(组大小)提到外层循环。"物品能否重复使用"是背包类问题最重要的区分点。)
#include <bits/stdc++.h>
using namespace std;
long long a[1005], dp[1005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[0] = 0; // 0 个人得 0 分
for (int i = 1; i <= n; i++) {
long long best = 0;
for (int k = 1; k <= i; k++) { // 枚举"最后一组"的人数
best = max(best, dp[i - k] + a[k]);
}
dp[i] = best;
}
printf("%lld\n", dp[n]);
return 0;
}// 整数划分型 DP 的通用骨架
dp[0] = 0;
for (int i = 1; i <= n; i++)
for (int k = 1; k <= i; k++) // 枚举"最后一块"的大小
dp[i] = max(dp[i], dp[i - k] + a[k]);
// 与背包问题的对照
// - 本题:dp[i] 表示"凑出总量 i"的最优值,k 可重复使用 -> 完全背包
// - 若题目改成"每种组大小最多用一次" -> 0/1 背包(外层变成枚举物品)
// 差别只在"循环顺序"和"物品是否可重复"
// 完全背包(本题形式)
for (int i = 1; i <= n; i++)
for (int k = 1; k <= i; k++) dp[i] = max(dp[i], dp[i-k] + a[k]);
// 类似题目
// - 把 n 拆成若干正整数之和,使某种收益最大
// - 找零钱问题(硬币面额可重复使用)
// - 分段问题(每段长度有不同收益)小杨同学给一家蛋糕店发送了一份自己的简历,希望可以在寒假来这里帮忙。店长最近正好遇到了一个难题:店里每天会做一条长条蛋糕,但是不同长度的蛋糕块卖出的价格不同,应该怎么分才能卖得最多呢?
有趣的是店长曾经学习过计算机专业。他最近对动态规划算法很感兴趣,于是打算用这个问题考一考小杨同学,问题如下:
- 给定一条长度为 n 的长条蛋糕和一个价格表,该价格表表示长度为 i(i = 1, 2, …, n)的蛋糕块的价格为 p_i。求蛋糕的分割方案,使得总销售价格最大,注意蛋糕块的长度必须为整数。
第二行 n 个正整数 p_1, p_2, …, p_n(1 ≤ p_i ≤ 10^5),表示不同长度蛋糕块的价格。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 5 8 9 | 10 |
| 2 | 10 1 5 8 9 10 17 17 20 24 30 | 30 |
第一个样例中,长度为 1 的蛋糕价值为 1,长度为 2 的蛋糕价值为 5,长度为 3 的蛋糕价值为 8,长度为 4 的蛋糕价值为 9;
总长度为 4 的长条蛋糕,有 {4}, {1, 3}, {2, 2}, {1, 1, 2}, {1, 1, 1, 1} 五种本质不同的分法。
其对应的总销售价格分别为 9, 9, 10, 7, 4,故最大总销售价格为 10。
第二个样例中,长度为 10 的长条蛋糕,销售价格最大的分法为 {10},最大总销售价格为 30。
写完后可到洛谷
P17012 对照题解。小杨的需求有如下几点:
1. 小杨想要尽可能尝试不同种类的饮料,因此他希望每种饮料至多购买 1 瓶;
2. 小杨很渴,所以他想要购买总容量不低于 L 的饮料;
3. 小杨勤俭节约,所以在 1 和 2 的前提下,他希望使用尽可能少的费用。
方便起见,你只需要输出最少花费的费用即可。特别地,如果不能满足小杨的要求,则输出 no solution。
接下来 N行,依次描述第 i=0,1,…,N-1 种饮料:每行两个整数 c_i,l_i。
no solution。| # | 输入 | 输出 |
|---|---|---|
| 1 | 5 100 100 2000 2 50 4 40 5 30 3 20 | 9 |
| 2 | 5 141 100 2000 2 50 4 40 5 30 3 20 | 100 |
| 3 | 4 141 2 50 4 40 5 30 3 20 | no solution |
小杨可以购买 1,2,4 号饮料,总计获得 50+40+20=110 毫升饮料,花费 2+4+3=9 元。
如果只考虑前两项需求,小杨也可以购买 1,3,4 号饮料,它们的容量总和为 50+30+20=100 毫升,恰好可以满足需求。但遗憾的是,这个方案需要花费 2+5+3=10 元。
样例 2 解释
1,2,3,4 号饮料总计 140 毫升,如每种饮料至多购买 1 瓶,则恰好无法满足需求,因此只能花费 100 元购买 0 号饮料。
数据规模
对于 40% 的测试点,保证 N ≤ 20;1≤ L ≤ 100; l_i ≤ 100。
对于 70% 的测试点,保证 l_i ≤ 100。
对于 100% 的测试点,保证 1≤ N ≤ 500;1≤ L ≤ 2000; 1≤ c_i,l_i ≤ 10^6。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
商店有 N 种饮料,第 i 种售价 cᵢ、容量 lᵢ。要求:每种至多买 1 瓶;总容量 ≥ L;在此前提下花费最少。若无论如何都满足不了容量要求,输出 no solution。
💡人话翻译:标准的"0/1 背包求最小费用"。
设 dp[v] = 让总容量恰好达到 v 所需的最少费用,其中容量超过 L 的一律"压"到 L 上(因为我们只关心"够不够",不关心超出多少)。
答案就是 dp[L];若它仍是"无穷大"就说明无解。
🔍 关键词提取
0/1 背包最小费用容量上限压缩无解判定
已知条件
项目说明
输入第一行 N、L;随后 N 行每行 cᵢ、lᵢ
输出最少费用,或 no solution
数据范围1 ≤ N ≤ 500,1 ≤ L ≤ 2000
花费/容量1 ≤ cᵢ, lᵢ ≤ 10⁶
目标总容量 ≥ L 且费用最小
需要解决的问题
为什么能"压缩容量"?因为只要总容量 ≥ L 就算满足,所以容量超过 L 的部分可以统一视作 L,这样 dp 数组只需开到 L + 1
为什么费用维度不能压?费用最大可达 500 × 10⁶ = 5 × 10⁸,按费用开数组太大了;而容量 L ≤ 2000 很小
转移怎么写?dp[min(L, v + lᵢ)] = min(dp[···], dp[v] + cᵢ)
🧠 状态
dp[v]:容量恰好 v 的最少费用
v 只取 0 ~ L
超过 L 的都压到 L
答案 = dp[L]
🔁 转移
对每种饮料 (c, l)
v 从 L 递减到 0(0/1 背包)
dp[min(L, v+l)] = min(…, dp[v] + c)
取 min
🚫 无解判定
初始化 dp[0] = 0,其余为 INF
跑完若 dp[L] 仍为 INF
说明凑不到 L 容量
输出 no solution
⚠️ 易错点
正序遍历 v(会重复购买)
忘记容量压缩导致越界
INF 设太小
费用和可能超 int
饮料:(100, 2000)、(2, 50)、(4, 40)、(5, 30)、(3, 20)(格式:花费, 容量)。
1
候选方案对比
买 (2,50)、(4,40)、(3,20):容量 110 ≥ 100,费用 9
买 (2,50)、(4,40)、(5,30):容量 120 ≥ 100,费用 11
买 (3,20)、(4,40)、(5,30):容量 90 < 100 ✗
买 (100,2000):容量 2000 ≥ 100,费用 100
只买 (2,50)、(4,40):容量 90 < 100 ✗
最小费用 9
2
DP 视角
dp[v] 记录"容量至少 v 的最低花费"
只容量恰好凑够才有值,超过 100 的压到 100
最终 dp[100] = 9(由容量 110 的方案压缩而来)
✅ dp[100] = 9
答案 9 ✓
🔑注意"容量压缩"的作用:方案的总容量是 110,但我们并不需要区分 110、120、2000——它们都"够用"。所以把它们统一记为到达 L = 100,dp 数组就只需要 101 个位置。
🧮 样例 2 与样例 3:无解是怎么出现的
样例 2 把 L 提到 141;样例 3 则去掉了那瓶"巨无霸"。
样例L可用饮料总容量能否满足答案
21415 种全有140 + 2000 = 2140能100
3141只有后 4 种50+40+30+20 = 140不能(140 < 141)no solution
1
样例 2 的取舍
若全买后 4 种:容量 140 < 141,不满足 ✗
所以必须买那瓶 (100, 2000)
容量瞬间达到 2000 ≥ 141,费用 100
虽然它单价贵,但"够用"是硬条件
✅ 100
2
样例 3 为什么无解
所有饮料容量之和 = 50 + 40 + 30 + 20 = 140
即使全买也只有 140 < 141
所以 dp[141] 永远是 INF
输出 no solution
✅ no solution
⚠️无解的判定很简单:如果所有饮料的容量之和都小于 L,那就一定无解(全买都不够)。
实现时不必特判——只要把 dp 初值设为"无穷大",递推结束后看 dp[L] 是否仍为无穷大即可。这与"有解时求出最小值"用同一套代码,非常优雅。
🟢 按容量做 0/1 背包(推荐) 推荐
dp[v] = 容量达到 v 的最少费用,容量压到 L
时间 O(NL) = 10⁶
N = 500、L = 2000 时轻松通过
代码 20 行
空间 O(L)
💡维度选择依据:容量维度只有 2001 个状态,而费用维度可达 5 × 10⁸——所以必须把"容量"当维度、把"费用"当值。
🟠 按费用做背包
dp[费用] = 最大容量,再找最小的费用使容量 ≥ L
费用上限 500 × 10⁶ = 5 × 10⁸
数组开不下
时间也不可能
完全不可行
⚠️量级对比:容量 2000 vs 费用 5 × 10⁸——差了 25 万倍。背包题永远选"范围更小"的那个当维度。
📈 性能对比
方案状态数可行性
按容量 DP≤ 2001✅ 稳过
按费用 DP≈ 5 × 10⁸❌ 不可行
按容量/性价比贪心—❌ 0/1 背包下不保证最优
第一行输入 N 和 L,随后 N 行输入每种的售价与容量。
输入数据5 100
100 2000
2 50
4 40
5 30
3 20
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18;
long long dp[2005]; // dp[v]:容量达到 v 的最少费用
int main() {
int N, L;
scanf("%d %d", &N, &L);
for (int v = 0; v <= L; v++) dp[v] = INF;
dp[0] = 0;
for (int i = 0; i < N; i++) {
long long c, l;
scanf("%lld %lld", &c, &l);
// 0/1 背包:容量维度倒序遍历
for (int v = L; v >= 0; v--) {
if (dp[v] == INF) continue;
int nv = (int)min((long long)L, (long long)v + l); // 容量压缩
dp[nv] = min(dp[nv], dp[v] + c);
}
}
if (dp[L] == INF) puts("no solution");
else printf("%lld\n", dp[L]);
return 0;
}
🔑为什么 v 要倒序遍历?这是 0/1 背包的标准要求:倒序时 dp[v] 还是"没考虑第 i 件"的旧值,保证每种饮料最多买一瓶。
若正序遍历,dp[v] 可能已经被本件更新过,就会变成"可以重复购买"(完全背包),与题意不符。
📖 关键几行怎么看
代码作用为什么这样写
dp[0] = 0,其余 INF初始化容量 0 免费达成,其他暂不可达
for (v = L; v >= 0; v--)倒序保证 0/1 特性
nv = min(L, v + l)容量压缩超过 L 一律压到 L
dp[nv] = min(dp[nv], dp[v] + c)转移取最小费用
dp[L] == INF无解判定从未被更新说明凑不够
⚠️四个坑:① 正序遍历(变成完全背包);② 容量越界(忘记 min(L, …));③ INF 取得太小导致被误判为可达;④ 费用之和超过 int(500 × 10⁶ = 5 × 10⁸ 虽在 int 内,但保险起见用 long long)。
写完程序后,用这些数据自查一遍:
输入答案考察点
5 100
100 2000 / 2 50 / 4 40 / 5 30 / 3 209题面样例 1
5 141
100 2000 / 2 50 / 4 40 / 5 30 / 3 20100题面样例 2(必须买贵的才够量)
4 141
2 50 / 4 40 / 5 30 / 3 20no solution题面样例 3(总量不够)
1 1
7 17只有一瓶,刚好够
1 5
1 1no solution容量不够,无解
✅自查清单:① 倒序遍历吗?② 压缩容量了吗?③ 判无解了吗?
🚨 易错点清单
⚠️正序遍历:会退化成"可以重复买",必须倒序。
⚠️忘记压缩容量:v + l 可能超过 L,要用 min(L, v+l)。
⚠️无解判定漏掉:dp[L] 仍是 INF 时要输出 no solution。
时间复杂度
O(NL)
空间复杂度
O(L)
N, L 最大
500 × 2000
运算量
约 10⁶
时间怎么算的?
N 种饮料
每种遍历容量状态 0 ~ L
合计 N × (L+1) ≤ 10⁶
空间都用在哪?
一个长度 L+1 的 dp 数组(L ≤ 2000)。
✅ 约 100 万次操作,瞬间完成。关键在于"用容量当维度、费用当值",这样状态数才够小。
// 0/1 背包求"容量至少 L 的最少费用"
// 核心:把"至少"通过容量压缩变成"恰好"
for (int v = 0; v <= L; v++) dp[v] = INF;
dp[0] = 0;
for (每个物品) for (int v = L; v >= 0; v--) {
if (dp[v] == INF) continue;
int nv = min(L, v + 物品容量);
dp[nv] = min(dp[nv], dp[v] + 物品费用);
}
// 答案 = dp[L](若仍为 INF 则无解)
// 背包题选择维度的原则
// 比较"容量范围"和"价值范围",用更小的那个当维度
// 本题:容量 ≤ 2000,费用可达 5×10^8 -> 选容量
// 经典 0/1 背包:容量 ≤ 1e5,价值可达 1e9 -> 也选容量
// "至少"型背包的通用技巧
// 把超过上界的部分全部压到上界,避免数组开大
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
容量压缩"至少 L" 转成 "恰好 L"所有"达到某阈值即可"的背包
0/1 倒序保证每件最多用一次所有 0/1 背包
维度选择用范围小的当维度背包、DP 的状态设计
🌟思考题:如果题目改成"每种饮料可以买任意多瓶"(即完全背包),代码要怎么改?(提示:把容量维度的循环改成正序即可——正序时 dp[v] 可能已经用过本件,正好实现"重复购买"。倒序 vs 正序,是背包问题最经典的一个记忆点。)
#include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18;
long long dp[2005]; // dp[v]:容量达到 v 的最少费用
int main() {
int N, L;
scanf("%d %d", &N, &L);
for (int v = 0; v <= L; v++) dp[v] = INF;
dp[0] = 0;
for (int i = 0; i < N; i++) {
long long c, l;
scanf("%lld %lld", &c, &l);
// 0/1 背包:容量维度倒序遍历
for (int v = L; v >= 0; v--) {
if (dp[v] == INF) continue;
int nv = (int)min((long long)L, (long long)v + l); // 容量压缩
dp[nv] = min(dp[nv], dp[v] + c);
}
}
if (dp[L] == INF) puts("no solution");
else printf("%lld\n", dp[L]);
return 0;
}// 0/1 背包求"容量至少 L 的最少费用"
// 核心:把"至少"通过容量压缩变成"恰好"
for (int v = 0; v <= L; v++) dp[v] = INF;
dp[0] = 0;
for (每个物品) for (int v = L; v >= 0; v--) {
if (dp[v] == INF) continue;
int nv = min(L, v + 物品容量);
dp[nv] = min(dp[nv], dp[v] + 物品费用);
}
// 答案 = dp[L](若仍为 INF 则无解)
// 背包题选择维度的原则
// 比较"容量范围"和"价值范围",用更小的那个当维度
// 本题:容量 ≤ 2000,费用可达 5×10^8 -> 选容量
// 经典 0/1 背包:容量 ≤ 1e5,价值可达 1e9 -> 也选容量
// "至少"型背包的通用技巧
// 把超过上界的部分全部压到上界,避免数组开大小杨设置了一个包含 n 个正整数的计分序列 A=[a_1,a_2,…,a_n],如果字符串的一个子串由 k(1≤q k ≤q n) 个 \texttt{abc} 首尾相接组成,那么能够得到分数 a_k,并且字符串包含的字符不能够重复计算得分,整个字符串的得分是计分子串的总和。
例如,假设 ,字符串 \texttt{dabcabcabcabzabc} 的所有可能计分方式如下:
- \texttt{d+abc+abcabc+abz+abc} 或者 \texttt{d+abcabc+abc+abz+abc},其中 \texttt{d} 和 \texttt{abz} 不计算得分,总得分为 a_1+a_2+a_1。
- \texttt{d+abc+abc+abc+abz+abc},总得分为 a_1+a_1+a_1+a_1。
- \texttt{d+abcabcabc+abz+abc},总得分为 a_3+a_1。
小杨想知道对于给定的字符串,最大总得分是多少。
- 第二行包含 n 个正整数,代表计分序列 A。
- 第三行包含一个正整数 m,代表字符串的长度。
- 第四行包含一个由 m 个小写字母组成的字符串。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 3 1 2 13 dabcabcabcabz | 9 |
最优的计分方式为 \texttt{d+abc+abc+abc+abz},总得分为 a_1+a_1+a_1,共 9 分。
数据范围
子任务编号|数据点占比|n|m|a_i|特殊性质
:-:|:-:|:-:|:-:|:-:|:-:
1|20%|≤ 20|≤ 10^5|≤ 1000|对于所有的 i(1 ≤ i ≤ n),存在 a_i ≥ a_{i+1}
2|40%|≤ 3|≤ 10^5|≤ 1000|
3|40%|≤ 20|≤ 10^5|≤ 1000|
对于全部数据,保证有 1≤q n≤q 20,1≤q m≤q 10^5,1≤q a_i≤q 1000。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定字符串 S(长度 m)和计分序列 A[1..n]。若一个子串由 k 个 abc 首尾相接组成,则能得 a_k 分。不同计分子串的字符不能重叠,总分是所有计分子串得分之和。求最大总分。
💡人话翻译:可计分的子串只有一种形式——abc、abcabc、abcabcabc…(即若干个连续的 abc 拼起来)。
设 dp[i] = 前 i 个字符能拿到的最大总分。转移有两条路:① 第 i 个字符不参与计分 → dp[i] = dp[i−1];② 以第 i 个字符结尾、长度为 3k 的块可计分 → dp[i] = dp[i−3k] + a_k。
由于 n ≤ 20,k 只需枚举 1 ~ 20,整体复杂度 O(nm) = 2 × 10⁶,非常轻松。
🔍 关键词提取
前缀 DP不重叠选择连块枚举n 小是突破口
已知条件
项目说明
输入第一行 n;第二行 A;第三行 m;第四行字符串 S
输出最大总分
数据范围1 ≤ n ≤ 20,1 ≤ m ≤ 10⁵
分值1 ≤ aᵢ ≤ 1000
约束计分子串之间字符不能重复使用
需要解决的问题
哪些子串可以计分?只有形如 (abc)^k 的(k ≤ n);可以用一个"单位"数组标记:unit[i] = 1 表示 S[i..i+2] == "abc"
怎么判断"以 i 结尾、长度 3k"的块合法?需要 S[i−3k .. i−1] 恰好是 k 个连续的 abc,即这 k 个单位首尾相接
为什么 n ≤ 20 是关键?因为内层只需枚举 k = 1 ~ 20,不必枚举 m 种长度
🧱 预处理单位
unit[i] 表示 S[i..i+2] 是否为 "abc"
只有这些位置能作为块的起点
块必须由连续单位组成
不同单位间不重叠
🧠 状态定义
dp[i]:前 i 个字符的最大总分
dp[0] = 0
答案 = dp[m]
按前缀长度递推
🔁 转移
方案一:不用第 i 个字符 → dp[i−1]
方案二:以 i 结尾取长度 3k 的块
要求这 k 个单位连续
n ≤ 20,所以 k 只枚举 1 ~ 20
⚠️ 易错点
块内部含非 abc 字符(必须逐单位校验)
把不连续的单位当成一块
忘记"不使用该字符"这条转移
用 int(总分可达 2 × 10⁷,安全但建议 long long)
先标出所有 abc 单位(下标从 1 开始)。
起点覆盖下标内容是否单位
22–4abc✓
55–7abc✓
88–10abc✓
1111–13abz✗
单位 2、5、8 连续(间隔恰好 3)→ 构成一个长度 3 的"连块"
1
这个连块可以怎么切?
整块取 k = 3 → a₃ = 2 分
切成 1 + 2 或 2 + 1 → a₁ + a₂ = 3 + 1 = 4 分
切成 1 + 1 + 1 → 3 × a₁ = 3 × 3 = 9 分 ← 最大
(注意块不能跨过 "abz",因为那不是 abc)
最优 9 分
2
DP 逐步计算
dp[0..3] = 0(前三个字符构不成完整块)
dp[4] = max(dp[3], dp[1] + a₁) = max(0, 3) = 3
dp[7] = max(dp[6], dp[4] + a₁, dp[1] + a₂)
= max(3, 3 + 3, 0 + 1) = 6
dp[10] = max(dp[9], dp[7]+a₁, dp[4]+a₂, dp[1]+a₃)
= max(6, 9, 4, 2) = 9
dp[11..13] = 9(后面没有可计分的块)
✅ 答案 9
9 ✓ 与样例一致(d + abc + abc + abc + abz)
🔑注意这个关键点:块必须由"连续的 abc 单位"组成。样例里 abz 不是单位,所以任何跨越它的块都不合法。
实现时最稳的做法是:从 i 往前每次退 3 个字符,检查这一段是否等于 "abc";一旦不相等就立即停止枚举(因为更长的块也不可能合法了)。
🧮 为什么内层循环可以不写成 O(m)
这是本题复杂度能过关的核心原因。
1
如果 n 很大
若 n 也达到 10⁵,那么对每个 i 都要枚举 k = 1..O(i/3)
复杂度变成 O(m²/3) ≈ 3 × 10⁹
会超时
n 大时不可行
2
本题 n ≤ 20
k 只需枚举 1 ~ 20
因此每个 i 的内层最多 20 次
总计 20 × 10⁵ = 2 × 10⁶
非常轻松
✅ O(nm)
📊 复杂度对照
内层枚举范围总运算量(m = 10⁵)可行性
k = 1 ~ n(≤ 20)2 × 10⁶✅ 轻松
k = 1 ~ i/3(最坏)约 3 × 10⁹❌ 超时
⚠️这道题的"数据范围"就是解法提示:题目特意把 n 限得很小(≤ 20)、而 m 很大(10⁵)。
这种"一大一小"的范围组合,通常意味着"外层扫大维度、内层只枚举小维度"。本题正是如此。
🟢 前缀 DP(推荐) 推荐
dp[i] 考虑"不用第 i 符"与"以 i 结尾取 3k 长的块"
时间 O(nm) = 2 × 10⁶
代码 25 行
空间 O(m)
n ≤ 20 使内层极短
💡内层校验的写法:从 i 往前每退 3 个字符检查一次是否等于 "abc",一旦不符合立即 break——因为"更长的块"必然也包含这段不合法的部分。
🟠 搜索所有划分方式
枚举每段的切分与长度,递归求最大
划分方式指数级
m = 10⁵ 完全不可行
只能处理 m ≤ 20 左右
不适合
⚠️为什么必须用 DP:"在序列上选不重叠区间求最大权"这类问题,几乎都用"前缀 DP + 枚举最后一段"。搜索只在 m 极小时可行。
📈 性能对比
方案复杂度可行性
前缀 DPO(nm)✅ 稳过
搜索切分指数级❌ 不可行
第一行输入各 k 的分值,第二行输入字符串,程序会算出最大总分。
输入数据3 1 2
dabcabcabcabz
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long a[25], dp[100005];
char s[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
int m;
scanf("%d", &m);
scanf("%s", s + 1); // 1-based,方便 dp 按"前 i 个字符"定义
dp[0] = 0;
for (int i = 1; i <= m; i++) {
dp[i] = dp[i - 1]; // 方案一:第 i 个字符不计分
// 方案二:以 i 结尾取长度为 3k 的块
for (int k = 1; k <= n; k++) {
int j = i - 3 * k;
if (j < 0) break;
// 检查 S[j+1 .. j+3] 是否为 "abc"(该块的最后一节)
if (!(s[j + 1] == 'a' && s[j + 2] == 'b' && s[j + 3] == 'c')) break;
dp[i] = max(dp[i], dp[j] + a[k]);
}
}
printf("%lld\n", dp[m]);
return 0;
}
🔑为什么"检查最后一节不是 abc 就可以 break"?因为长度为 3k 的块,它末尾那一节必须是 abc。
如果连末尾这一节都不是 abc,那么长度更长(k 更大)的块也一定不合法(它们都以同样的一节结尾)。所以可以安全地提前退出,把内层循环压得更短。
📖 关键几行怎么看
代码作用为什么这样写
dp[i] = dp[i-1]方案一不用第 i 个字符
for (k = 1; k <= n; k++)枚举块大小n ≤ 20,内层极短
j = i − 3k起点长度 3k 的块起点
if (!(s[j+1]==a && ...)) break;合法性校验末尾不是 abc 则更长的块也不合法
dp[i] = max(dp[i], dp[j] + a[k])转移取块 + 之前的最优
⚠️四个坑:① 忘记 dp[i] = dp[i−1] 这条转移(会导致必须"每段都计分"才能更新,漏解);② 内层不 break(会去检查不合法的长块,甚至用错的下标);③ 字符串下标混用 0/1 基;④ 以为 a_k 随 k 递增(题目没这个保证,必须都枚举)。
写完程序后,用这些数据自查一遍:
输入答案考察点
3
3 1 2
13
dabcabcabcabz9题面样例(切成三段 abc)
3
3 1 2
6
abcabc6两段 k=1 得 3+3=6,优于整段 k=2 的 1
1
5
3
abc5恰好一个 abc 块
1
5
2
ab0构不成 abc,得分 0
2
10 10
6
abcabc20两个 k=1 的块,各得 10
2
10 1
6
abcabc20同样切成两段更优(k=2 只给 1)
✅自查清单:① 有不使用转移吗?② 内层 break 吗?③ 枚举了所有 k 吗?
🚨 易错点清单
⚠️漏掉"不使用"这条转移:dp[i] 必须能继承 dp[i−1]。
⚠️内层不 break:末尾不是 abc 时更长的块也不合法。
⚠️以为 A 单调:a_k 不一定随 k 递增,必须枚举所有 k。
时间复杂度
O(nm)
空间复杂度
O(m)
n, m 最大
20 × 10⁵
运算量
约 2 × 10⁶
时间怎么算的?
外层扫描 m 个位置
内层最多枚举 n ≤ 20 个块大小
合计 n × m ≤ 2 × 10⁶
空间都用在哪?
dp 数组长度 m+1,分值数组长度 n+1。
✅ 约 200 万次操作,瞬间完成。本题的关键是"看数据范围定算法":n 小、m 大 → 内层枚举 n。
// 前缀 DP + 不重叠区间选择的通用骨架
dp[0] = 0;
for (int i = 1; i <= m; i++) {
dp[i] = dp[i-1]; // 不做任何事
for (每个以 i 结尾的合法区间 [j+1, i]) // 本题里 j = i - 3k
dp[i] = max(dp[i], dp[j] + 价值(该区间));
}
// 答案 = dp[m]
// 本题的合法区间:长度 3k、内容恰为 k 个连续的 abc
// 校验技巧:从末尾往前 3 个一组校验,不合法立即 break
// 类似的"区间不重叠取最大权"问题
// - 活动选择(按结束时间 DP)
// - 字符串分段计分
// - 任务调度取最大收益(需排序 + 二分)
// 若 n 也可以很大,就需要更高级的手段
// (如:只在"连块"内部做一次前缀 DP,按连块分段处理)
// 即先把字符串拆成若干"由连续 abc 组成"的极大连块,
// 每个连块内部是个独立的 unbounded 背包型 DP
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
前缀 DPdp[i] 表示前 i 位最优所有"序列上选不重叠区间"的问题
提前 break不合法后更长区间也不合法可行性具有单调性的枚举
看范围定算法小维度内层、大维度外层数据范围一大一小时的通法
🌟思考题:本题的 n 只有 20,所以内层枚举 k 很轻松。如果 n 也放大到 10⁵,你会怎么优化?(提示:可以先把字符串切成若干"极大连块"(由连续 abc 组成的最长段),每个连块长度记作 L;在连块内部就变成"把 L 拆成若干份、使 Σ a[份大小] 最大"的完全背包问题,而连块之间互不影响。这样总复杂度由"所有连块长度的平方和"决定,在实践中通常远小于 m²。)
#include <bits/stdc++.h>
using namespace std;
long long a[25], dp[100005];
char s[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
int m;
scanf("%d", &m);
scanf("%s", s + 1); // 1-based,方便 dp 按"前 i 个字符"定义
dp[0] = 0;
for (int i = 1; i <= m; i++) {
dp[i] = dp[i - 1]; // 方案一:第 i 个字符不计分
// 方案二:以 i 结尾取长度为 3k 的块
for (int k = 1; k <= n; k++) {
int j = i - 3 * k;
if (j < 0) break;
// 检查 S[j+1 .. j+3] 是否为 "abc"(该块的最后一节)
if (!(s[j + 1] == 'a' && s[j + 2] == 'b' && s[j + 3] == 'c')) break;
dp[i] = max(dp[i], dp[j] + a[k]);
}
}
printf("%lld\n", dp[m]);
return 0;
}// 前缀 DP + 不重叠区间选择的通用骨架
dp[0] = 0;
for (int i = 1; i <= m; i++) {
dp[i] = dp[i-1]; // 不做任何事
for (每个以 i 结尾的合法区间 [j+1, i]) // 本题里 j = i - 3k
dp[i] = max(dp[i], dp[j] + 价值(该区间));
}
// 答案 = dp[m]
// 本题的合法区间:长度 3k、内容恰为 k 个连续的 abc
// 校验技巧:从末尾往前 3 个一组校验,不合法立即 break
// 类似的"区间不重叠取最大权"问题
// - 活动选择(按结束时间 DP)
// - 字符串分段计分
// - 任务调度取最大收益(需排序 + 二分)
// 若 n 也可以很大,就需要更高级的手段
// (如:只在"连块"内部做一次前缀 DP,按连块分段处理)
// 即先把字符串拆成若干"由连续 abc 组成"的极大连块,
// 每个连块内部是个独立的 unbounded 背包型 DP接下来 n 行,每行两个正整数 a_i,c_i,表示道具所提升的攻击力点数,以及购买所需的金币数量。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 5 99 1 33 2 11 3 | 132 |
| 2 | 4 100 10 1 20 11 40 33 100 99 | 110 |
对于所有测试点,保证 1≤ n≤ 500,1
≤ k≤ 10^9,1≤ a_i≤ 500,1≤ c_i≤ 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
道具商店有 n 件道具。第 i 件提升 aᵢ 点攻击力,需要 cᵢ 枚金币,每件只能购买一次。现有 k 枚金币,求最多能提升多少点攻击力。
💡人话翻译:这是 0/1 背包,但背包容量 k 可达 10⁹,按容量开数组会爆内存。
注意数据特点:aᵢ ≤ 500 且 n ≤ 500,所以总攻击力 ≤ 250000——很小!所以把 DP 的维度换成"价值":求"恰好达到 v 点攻击力所需的最小金币数"。
🔍 关键词提取
0/1 背包维度互换min 型 DP大容量背包
已知条件
项目说明
输入第一行 n、k;随后 n 行 aᵢ、cᵢ
输出最多提升的攻击力
数据范围1 ≤ n ≤ 500
容量1 ≤ k ≤ 10⁹(很大!)
价值1 ≤ aᵢ ≤ 500(很小!)
花费1 ≤ cᵢ ≤ 10⁹
需要解决的问题
为什么不能按容量 DP?dp[k] 需要 10⁹ 大小的数组,内存和时间都不允许
怎么换维度?定义 dp[v] = 恰好凑出 v 点攻击力的最小花费;答案是满足 dp[v] ≤ k 的最大 v
状态空间多大?Σaᵢ ≤ 500 × 500 = 250000,完全可行
🧠 常规背包
dp[容量] = 最大价值
容量 k 可达 10⁹
数组开不下
所以不能这样做
🔄 维度互换
改设 dp[价值] = 最小花费
价值总和 ≤ 250000
数组大小 = Σa + 1
完全可行
🔁 转移
对每件道具 (a, c)
v 从大到小遍历(0/1 背包)
dp[v] = min(dp[v], dp[v−a] + c)
取 min 而非 max
✅ 求答案
找满足 dp[v] ≤ k 的最大 v
从 Σa 往下扫
第一个满足的就是答案
(或全部扫描取最大)
总攻击力 Σa = 99 + 33 + 11 = 143,所以 dp 数组大小取 144。
1
初始化
dp[0] = 0(凑 0 点攻击力花费 0)
其他 dp[v] = 无穷大(表示暂时无法凑出)
dp[0] = 0
2
加入道具 (99, 1)
v 从 143 递减到 99:
dp[99] = min(∞, dp[0] + 1) = 1
其他位置仍为 ∞
dp[99] = 1
3
加入道具 (33, 2)
dp[33] = dp[0] + 2 = 2
dp[132] = dp[99] + 2 = 3
其余不变
dp[33] = 2,dp[132] = 3
4
加入道具 (11, 3)
dp[11] = 3,dp[44] = dp[33]+3 = 5
dp[110] = dp[99]+3 = 4,dp[143] = dp[132]+3 = 6
其余不变
dp[143] = 6
5
找 dp[v] ≤ k = 5 的最大 v
v = 143:dp = 6 > 5 ✗
v = 132:dp = 3 ≤ 5 ✓
(110 的 dp = 4 也 ≤ 5,但 132 更大)
所以答案是 132
✅ 132
组合攻击力花费≤ k = 5?
99 + 33 + 111436✗
99 + 331323✓
99 + 111104✓
33 + 11445✓
99991✓
答案 132 ✓
🧮 样例 2:n = 4,k = 100,道具 (10,1)、(20,11)、(40,33)、(100,99)
这组数据里"单价"差异很大,正好体现背包的必要性。
组合攻击力花费≤ k = 100?
10010099✓
10 + 100110100✓
20 + 40 + 107045✓
20 + 100120110✗
40 + 100140132✗
10 + 20 + 100130111✗
20 + 40 + 10 + 100170144✗
答案 110 ✓
💡注意本题更看重"总花费"而不是"单价"。虽然 (10, 1) 的性价比极高(10 攻击力只花 1 金币),但预算只有 100,所以必须靠 DP 枚举组合才能找到 110 这个最优值。贪心(按性价比排序)在 0/1 背包里是不保证正确的。
🟢 按价值 DP(推荐) 推荐
dp[v] = 恰好凑出 v 点攻击力的最小花费,最后找 dp[v] ≤ k 的最大 v
时间 O(n × Σa) ≤ 500 × 250000 = 1.25 × 10⁸
空间 O(Σa) = 250001 个 long long(约 2 MB)
转移取 min
本质是 0/1 背包换维度
💡为什么可以这样做:因为 Σaᵢ ≤ n × max(aᵢ) = 500 × 500 = 250000,价值维度很小。而容量 k 高达 10⁹,这种"容量大、价值小"的背包就是靠换维度解决的。
🟠 按容量 DP
dp[j] = 花费 ≤ j 时的最大攻击力,j 从 0 到 k
数组需要 10⁹ + 1 个元素
内存约 8 GB
直接爆内存
时间也不可能
⚠️量级对比:容量维度 10⁹ vs 价值维度 2.5 × 10⁵——差了 4000 倍。背包题的维度选择 = 看"哪个范围小",这是最重要的解题判断。
📈 性能对比
方案空间可行性
按价值 DP约 2 MB✅ 可过
按容量 DP约 8 GB❌ 爆内存
贪心按性价比O(1)❌ 0/1 背包下不正确
第一行输入 n 和 k,随后 n 行输入每件道具的攻击力与花费。
输入数据3 5
99 1
33 2
11 3
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18; // 足够大的"无穷"
long long dp[250005]; // dp[v] = 凑出 v 点攻击力的最小花费
int main() {
int n;
long long k;
scanf("%d %lld", &n, &k);
vector<int> a(n);
vector<long long> c(n);
int S = 0;
for (int i = 0; i < n; i++) {
scanf("%d %lld", &a[i], &c[i]);
S += a[i]; // 总攻击力上限
}
// dp[0] = 0,其余为无穷大
for (int v = 0; v <= S; v++) dp[v] = INF;
dp[0] = 0;
// 按价值维度做 0/1 背包
for (int i = 0; i < n; i++) {
for (int v = S; v >= a[i]; v--) { // 倒序:保证每件只用一次
if (dp[v - a[i]] + c[i] < dp[v])
dp[v] = dp[v - a[i]] + c[i];
}
}
// 找满足 dp[v] <= k 的最大 v
for (int v = S; v >= 0; v--) {
if (dp[v] <= k) { printf("%d\n", v); break; }
}
return 0;
}
🔑为什么 v 要倒序遍历?这是 0/1 背包的标准技巧。倒序时 dp[v - a[i]] 还是"没考虑第 i 件"的旧值,保证每件道具最多用一次;若正序遍历,dp[v - a[i]] 可能已经用过了第 i 件,就变成"完全背包"(可以无限用)了。另外注意转移用的是 min(因为 dp 存的是最小花费)。
📖 关键几行怎么看
代码作用为什么这样写
S += a[i]价值上限数组只需开到总攻击力
dp[0] = 0,其余 INF初始化只有"凑 0 点"是免费可达的
for (v = S; v >= a[i]; v--)倒序遍历0/1 背包的关键
min(dp[v], dp[v-a[i]] + c[i])转移求最小花费
if (dp[v] <= k)答案从大到小找第一个可达的
⚠️四个坑:① 按容量开数组(k 达 10⁹,爆内存);② 价值循环写成正序(变成完全背包);③ INF 设太小(cᵢ 可达 10⁹,加几次就超过 int 范围,要用 long long 的 4e18);④ 忘记 dp[0] = 0 的初始化。
写完程序后,用这些数据自查一遍:
输入答案考察点
3 5
99 1 / 33 2 / 11 3132题面样例 1:选 99 + 33
4 100
10 1 / 20 11 / 40 33 / 100 99110题面样例 2:选 10 + 100
1 1
5 15刚好买得起
1 1
5 20买不起(花费 2 超过预算 1)
2 3
1 2 / 1 21只买得起一件
2 10
500 1000000000 / 1 11花费远大于预算,只能买便宜的
✅自查清单:① 按价值开数组吗?② 倒序遍历吗?③ dp[0] = 0 初始化了吗?
🚨 易错点清单
⚠️按容量 DP:k 可达 10⁹,数组开不下,必须把维度换到"价值"上。
⚠️价值循环正序:会退化成"完全背包"(同一件可重复买),必须倒序。
⚠️INF 太小:cᵢ 可达 10⁹,INF 要用 long long 的大值。
时间复杂度
O(n × Σa)
空间复杂度
O(Σa)
最坏运算
≤ 500 × 250000 = 1.25 × 10⁸
数组大小
约 2 MB
时间怎么算的?
n ≤ 500 件道具
每件遍历价值空间 Σa ≤ 250000
合计 ≤ 1.25 × 10⁸ 次
k 的大小完全不影响复杂度
空间都用在哪?
dp[0..Σa],最多 250001 个 long long,约 2 MB。
✅ 约 1.25 亿次简单比较与加法,C++ 约 0.2 ~ 0.5 秒,可通过。如果卡常,可以只维护实际可达的状态(用 vector 去重)。
// 0/1 背包两种维度的对比
// 按容量:dp[j] = 花费不超过 j 时的最大价值(j 为容量)
// 按价值:dp[v] = 达到价值 v 所需的最小花费(v 为价值)
// 选择依据:谁的取值范围小就用谁当维度
// 按价值维度的标准骨架
for (int v = 0; v <= S; v++) dp[v] = INF;
dp[0] = 0;
for (每个物品 i)
for (int v = S; v >= a[i]; v--) // 倒序!
dp[v] = min(dp[v], dp[v - a[i]] + c[i]);
// 答案:满足 dp[v] <= k 的最大 v
// INF 的选取:要大于"任何可能的合法花费之和"
// 本题 c_i <= 10^9,n <= 500 -> 合法花费 <= 5 * 10^11
// 但为避免加法溢出,取 4e18(long long 的 1/4)较稳妥
// 空间优化:可以用两个 vector 或滚动数组
// 但本题价值维度不大,直接用一维数组即可
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
维度互换容量大就用价值当维度大容量、小价值的背包题
0/1 背包倒序保证每件只用一次所有 0/1 背包
min 型 DPdp 存最小花费"达到某价值的最小代价"类问题
🌟思考题:如果题目改成"每件道具可以买无限多件",要改哪里?(提示:把价值循环改成正序即可——正序时 dp[v - a[i]] 可能已经用过第 i 件,正好实现了"重复购买"。倒序 = 0/1 背包,正序 = 完全背包,这是背包问题最经典的一个记忆点。)
#include <bits/stdc++.h>
using namespace std;
const long long INF = 4e18; // 足够大的"无穷"
long long dp[250005]; // dp[v] = 凑出 v 点攻击力的最小花费
int main() {
int n;
long long k;
scanf("%d %lld", &n, &k);
vector<int> a(n);
vector<long long> c(n);
int S = 0;
for (int i = 0; i < n; i++) {
scanf("%d %lld", &a[i], &c[i]);
S += a[i]; // 总攻击力上限
}
// dp[0] = 0,其余为无穷大
for (int v = 0; v <= S; v++) dp[v] = INF;
dp[0] = 0;
// 按价值维度做 0/1 背包
for (int i = 0; i < n; i++) {
for (int v = S; v >= a[i]; v--) { // 倒序:保证每件只用一次
if (dp[v - a[i]] + c[i] < dp[v])
dp[v] = dp[v - a[i]] + c[i];
}
}
// 找满足 dp[v] <= k 的最大 v
for (int v = S; v >= 0; v--) {
if (dp[v] <= k) { printf("%d\n", v); break; }
}
return 0;
}// 0/1 背包两种维度的对比
// 按容量:dp[j] = 花费不超过 j 时的最大价值(j 为容量)
// 按价值:dp[v] = 达到价值 v 所需的最小花费(v 为价值)
// 选择依据:谁的取值范围小就用谁当维度
// 按价值维度的标准骨架
for (int v = 0; v <= S; v++) dp[v] = INF;
dp[0] = 0;
for (每个物品 i)
for (int v = S; v >= a[i]; v--) // 倒序!
dp[v] = min(dp[v], dp[v - a[i]] + c[i]);
// 答案:满足 dp[v] <= k 的最大 v
// INF 的选取:要大于"任何可能的合法花费之和"
// 本题 c_i <= 10^9,n <= 500 -> 合法花费 <= 5 * 10^11
// 但为避免加法溢出,取 4e18(long long 的 1/4)较稳妥
// 空间优化:可以用两个 vector 或滚动数组
// 但本题价值维度不大,直接用一维数组即可②编程打卡 · 点一下就能勾选
- 完成 P11246《小杨和整数拆分》,跑通全部样例
- 完成 P13015《学习小组》,跑通全部样例
- 完成 P17012《条形蛋糕》,跑通全部样例
- 完成 B3873《小杨买饮料》,跑通全部样例
- 完成 P10721《计算得分》,跑通全部样例
- 完成 P14920《道具商店》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
深度优先搜索 DFS
①本日知识点 · 深度优先搜索 DFS
递归出口先写;回溯时记得把状态改回去。
本组 2 道题全部来自 GESP 真题,按「深度优先搜索 DFS」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
该公司有严格的管理制度,每位员工只能受到本人或直接领导或间接领导的管理。具体来说,规定员工 x 可以管理员工 y,当且仅当 x=y,或 x=f_y,或 x 可以管理 f_y。特别地,0 号员工老板只能自我管理,无法由其他任何员工管理。
现在,有一些同事要开展合作,他们希望找到一位同事来主持这场合作,这位同事必须能够管理参与合作的所有同事。如果有多名满足这一条件的员工,他们希望找到编号最大的员工。你能帮帮他们吗?
第二行 N - 1 个用空格隔开的正整数,依次为 f_1,f_2,… f_{N−1}。
第三行一个整数 Q,表示共有 Q 场合作需要安排。
接下来 Q 行,每行描述一场合作:开头是一个整数 m(2 ≤ m ≤ N),表示参与本次合作的员工数量;接着是 m 个整数,依次表示参与本次合作的员工编号(保证编号合法且不重复)。
保证公司结构合法,即不存在任意一名员工,其本人是自己的直接或间接领导。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 5 0 0 2 2 3 2 3 4 3 2 3 4 2 1 4 | 2 2 0 |
| 2 | 7 0 1 0 2 1 2 5 2 4 6 2 4 5 3 4 5 6 4 2 4 5 6 2 3 4 | 2 1 1 1 0 |
对于第一场合作,员工 3,4 有共同领导 2 ,可以主持合作。
对于第二场合作,员工 2 本人即可以管理所有参与者。
对于第三场合作,只有 0 号老板才能管理所有员工。
数据范围
对于 50% 的测试点,保证 N ≤q 50。
对于所有测试点,保证 3 ≤q N ≤q 300,Q ≤q 100。
------------
2024/1/28 添加一组 hack 数据。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
公司有 N 名员工(编号 0 ~ N−1),0 号是老板,其余每人有直接领导 fᵢ。规定 x 能管理 y 当且仅当 x = y,或 x = f_y,或 x 能管理 f_y(即x 是 y 的祖先或本人)。
每场合作给出若干参与者,要找一位能管理所有参与者的主持者;若有多人满足,选编号最大的那位。
💡人话翻译:条件"能管理所有人"等价于"这位主持者是所有参与者的公共祖先(或本人)"。
所以解题分两步:① 预处理每个员工的完整祖先链(含本人,一直到 0 号);② 对每场合作,把所有人的祖先集合求交集,再取其中编号最大的。
N ≤ 300、Q ≤ 100 很小,直接暴力求交完全够快。
🔍 关键词提取
祖先链集合求交树上关系暴力枚举
已知条件
项目说明
输入第一行 N;第二行 f₁…f_{N−1};第三行 Q;随后 Q 行每行 m 与参与者
输出每行一个主持人编号
数据范围3 ≤ N ≤ 300,Q ≤ 100
管理关系x 管理 y ⟺ x 在 y 的祖先链上(含 y 自身)
选择规则所有可行者中取编号最大
需要解决的问题
怎么表示"能管理"?对每个员工 y,把它自己、它的领导、领导的领导…直到 0 号都记下来,构成一张"谁能管理 y"的名单
怎么找共同主持人?把参与者的名单求交集,交集中的每个人都能管理所有参与者
为什么取编号最大?题目明确规定:多位满足时选编号最大的——注意不是"层级最深"
🌳 建关系
员工 y 的领导是 f_y
0 号是老板(根)
每个员工可向上走任意层
一直到根 0
📋 预处理
对每个 y 收集祖先链(含自己)
用布尔数组标记"谁能管 y"
N ≤ 300 → 总规模很小
也可以直接用 vector 存
🔍 每场合作
取第一个人的名单作为候选
依次与其他人的名单求交
交集中取最大编号
输出该编号
⚠️ 易错点
把"编号最大"当成"层级最深"
忘记"本人也能管理自己"
交集的初始集合没设对
认为 f_i 一定小于 i
f₁ = 0、f₂ = 0、f₃ = 2、f₄ = 2。所以:2、3、4 号都直接向 0 号汇报?不——f₃ = 2 表示 3 号的领导是 2 号。
员工直接领导完整祖先链(含自己)
0(老板)0
101, 0
202, 0
323, 2, 0
424, 2, 0
1
第 1 场:参与者 3、4
3 的名单:{3, 2, 0}
4 的名单:{4, 2, 0}
交集:{2, 0}
取编号最大 → 2
输出 2 ✓
2
第 2 场:参与者 2、3、4
2 的名单:{2, 0}
与 {3, 2, 0} 求交 → {2, 0}
再与 {4, 2, 0} 求交 → {2, 0}
取最大 → 2
输出 2 ✓
3
第 3 场:参与者 1、4
1 的名单:{1, 0}
4 的名单:{4, 2, 0}
交集:{0}(只有老板)
取最大 → 0
输出 0 ✓
输出 2、2、0 ✓ 与样例一致
🔑注意第 3 场的解释:题目说"只有 0 号老板才能管理所有员工"——因为 1 号和 4 号分属不同分支(1 的上级是 0,4 的上级是 2、再往上才是 0),除了老板 0 号,没有别人能同时管住这两个人。
🧮 样例 2:验证"取最大编号"而非"层级最深"
N = 7,f = [0, 1, 0, 2, 1, 2]:
员工直接领导完整祖先链
0—0
101, 0
212, 1, 0
303, 0
424, 2, 1, 0
515, 1, 0
626, 2, 1, 0
1
第 1 场:4、6
4 的名单:{4, 2, 1, 0}
6 的名单:{6, 2, 1, 0}
交集:{2, 1, 0}
取最大编号 → 2(也是层级最深)
输出 2 ✓
2
第 3 场:4、5、6
4:{4, 2, 1, 0}
5:{5, 1, 0}
6:{6, 2, 1, 0}
三者交集:{1, 0}
取最大编号 → 1
输出 1 ✓
3
第 5 场:3、4
3:{3, 0}
4:{4, 2, 1, 0}
交集:{0}
→ 0
输出 0 ✓
输出 2、1、1、1、0 ✓ 与样例一致
⚠️关于"取最大编号"这一点:本题的样例里,编号最大的恰好也是层级最深的(即 LCA),但题目要求的是"编号最大",不是"层级最深"。
如果树的结构允许"浅层结点的编号比深层结点更大",两者就会不同。所以我们直接求"祖先集合的交集再取最大值",而不是求 LCA——这样最稳妥。
🟢 祖先集合求交(推荐) 推荐
预处理每人祖先链,每场合作求交集取最大值
预处理 O(N²)
每场合作 O(m · N)
总计 ≤ 100 × 300 × 300 = 9 × 10⁶
代码 30 行
💡为什么这样最稳:题目要的是"编号最大的可行者",而不是"层级最深的祖先"。直接枚举"所有公共祖先"再取最大值,完全贴合题意,不会因为树的结构特殊而错。
🟠 逐对求 LCA
先求所有参与者的 LCA,但还要再考虑 LCA 的祖先们
求 LCA 本身是对的
但"最大编号"可能出现在 LCA 的祖先上
容易漏掉
还需要额外遍历祖先
⚠️关键区别:如果题目问"最深的主持者",那就是 LCA;但本题问"编号最大的",必须把 LCA 及它的所有祖先都纳入比较。
所以"求交集取最大"反而更直接。
📈 性能对比
方案做法风险
祖先集合求交交集后取 max低
求 LCA还需再比较其祖先中(易漏)
第一行输入 N,第二行输入各员工的领导,第三行输入 Q,随后 Q 行输入参与者。
输入数据5
0 0 2 2
3
2 3 4
3 2 3 4
2 1 4
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int f[305];
bool anc[305][305]; // anc[y][x] = true 表示 x 能管理 y
int main() {
int N;
scanf("%d", &N);
f[0] = 0; // 老板自我管理
for (int i = 1; i < N; i++) scanf("%d", &f[i]);
// 预处理:对每个员工 y,标记它的所有祖先(含自己)
for (int y = 0; y < N; y++) {
int cur = y;
while (true) {
anc[y][cur] = true;
if (cur == 0) break; // 走到老板为止
cur = f[cur];
}
}
int Q;
scanf("%d", &Q);
while (Q--) {
int m;
scanf("%d", &m);
// 候选集:先取第一位参与者的祖先集合
bool cand[305];
for (int x = 0; x < N; x++) cand[x] = false;
for (int j = 0; j < m; j++) {
int y;
scanf("%d", &y);
if (j == 0) {
for (int x = 0; x < N; x++) cand[x] = anc[y][x];
} else {
for (int x = 0; x < N; x++) if (!anc[y][x]) cand[x] = false;
}
}
// 取编号最大的候选者
for (int x = N - 1; x >= 0; x--) {
if (cand[x]) { printf("%d\n", x); break; }
}
}
return 0;
}
🔑为什么用"祖先集合求交"而不是"求 LCA"?因为题目要求"编号最大",而不是"层级最深"。
集合交集恰好就是"所有可行主持人"的完整名单,从大到小扫一遍取第一个,既简洁又绝对不会漏。
另外注意 anc[y][y] = true——本人也能管理自己,所以参与者自己也可能成为主持人(样例 1 第 2 场就是 2 号自己主持)。
📖 关键几行怎么看
代码作用为什么这样写
f[0] = 0老板0 号自我管理,向上走就停
while (true) { anc[y][cur] = true; if (cur == 0) break; cur = f[cur]; }收集祖先链含自己,一直到根
cand[x] = anc[y][x](第一个参与者)初始化候选交集从第一个人的集合开始
if (!anc[y][x]) cand[x] = false;求交任何一人管不到的就淘汰
for (x = N−1; x >= 0; x--)取最大编号从大到小找第一个
⚠️四个坑:① 忘记"本人也能管理自己"(祖先链要含自身);② 候选集初始化成"全集"而不是"第一位参与者的集合"(会导致多出不存在的主持人);③ 以为 f_i < i 成立(题目只保证无环,不一定编号递增);④ 输出顺序与输入顺序不一致。
写完程序后,用这些数据自查一遍:
输入答案考察点
5
0 0 2 2
3
2 3 4 / 3 2 3 4 / 2 1 42
2
0题面样例 1
7
0 1 0 2 1 2
5
2 4 6 / 2 4 5 / 3 4 5 6 / 4 2 4 5 6 / 2 3 42
1
1
1
0题面样例 2
3
0 0
1
2 1 20两人分属不同分支,只能找老板
3
0 1
1
2 1 212 的上级是 1,1 能同时管住 1 和 2
3
0 0
1
2 0 10老板只能自我管理,无法被别人管理
✅自查清单:① 链含自己吗?② 交集初始化对吗?③ 取的是最大编号吗?
🚨 易错点清单
⚠️漏掉本人:祖先链必须包含自己,否则"参与者自己当主持人"的情况会漏。
⚠️候选集初始化错:应从第一位参与者的祖先集合开始求交。
⚠️误以为编号递增:题目只保证无环,所以要用"取最大编号"而不是"找最深结点"。
预处理
O(N²)
每场合作
O(m · N)
N 最大
300
总运算量
≤ 9 × 10⁶
时间怎么算的?
预处理祖先集合:N 个员工 × 链长 ≤ N → O(N²)
每场合作:m 个参与者各扫一遍 N 个候选 → O(m·N)
Q ≤ 100、m ≤ N = 300 → 总计 ≤ 9 × 10⁶
空间都用在哪?
一个 N × N 的布尔表(300 × 300),非常小。
✅ 约 900 万次布尔运算,瞬间完成。本题数据范围小,暴力求交是最省心的解法。
// 树上"谁能管理谁"的通用处理
// 1. 预处理每个点的祖先链(含自己,一直到根)
for (int y = 0; y < N; y++) {
int cur = y;
while (true) { anc[y][cur] = true; if (cur == 0) break; cur = f[cur]; }
}
// 2. "公共祖先" = 祖先集合的交集
// 求交后取最大值即为答案(本题要求编号最大)
// 3. 若题目要求"最深的主持者",则答案就是 LCA
// 求 LCA 的暴力写法(沿链上跳,沿链打标记)
int lca(int u, int v) {
bool on[305] = {false};
for (int x = u; ; x = f[x]) { on[x] = true; if (x == 0) break; }
for (int y = v; ; y = f[y]) { if (on[y]) return y; if (y == 0) break; }
return 0;
}
// 注意 f[i] 不一定小于 i,所以不能假设"编号小的层级浅"
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
祖先集合求交公共祖先的完整名单所有"谁能管住一组人"的问题
LCA最深的公共祖先树上距离、路径问题
布尔矩阵预处理O(N²) 存关系N 较小时的通用做法
🌟思考题:如果 N 放大到 10⁵、Q 也到 10⁵,本题该怎么做?(提示:就不能用 O(N²) 的布尔表了——需要先求所有参与者的 LCA(用倍增法 O(N log N) 预处理 + O(m log N) 查询),再在"LCA 及其祖先"中找编号最大的。而"编号最大"这个要求仍然需要额外处理——这也说明读清题目的"选择规则"有多重要。)
#include <bits/stdc++.h>
using namespace std;
int f[305];
bool anc[305][305]; // anc[y][x] = true 表示 x 能管理 y
int main() {
int N;
scanf("%d", &N);
f[0] = 0; // 老板自我管理
for (int i = 1; i < N; i++) scanf("%d", &f[i]);
// 预处理:对每个员工 y,标记它的所有祖先(含自己)
for (int y = 0; y < N; y++) {
int cur = y;
while (true) {
anc[y][cur] = true;
if (cur == 0) break; // 走到老板为止
cur = f[cur];
}
}
int Q;
scanf("%d", &Q);
while (Q--) {
int m;
scanf("%d", &m);
// 候选集:先取第一位参与者的祖先集合
bool cand[305];
for (int x = 0; x < N; x++) cand[x] = false;
for (int j = 0; j < m; j++) {
int y;
scanf("%d", &y);
if (j == 0) {
for (int x = 0; x < N; x++) cand[x] = anc[y][x];
} else {
for (int x = 0; x < N; x++) if (!anc[y][x]) cand[x] = false;
}
}
// 取编号最大的候选者
for (int x = N - 1; x >= 0; x--) {
if (cand[x]) { printf("%d\n", x); break; }
}
}
return 0;
}// 树上"谁能管理谁"的通用处理
// 1. 预处理每个点的祖先链(含自己,一直到根)
for (int y = 0; y < N; y++) {
int cur = y;
while (true) { anc[y][cur] = true; if (cur == 0) break; cur = f[cur]; }
}
// 2. "公共祖先" = 祖先集合的交集
// 求交后取最大值即为答案(本题要求编号最大)
// 3. 若题目要求"最深的主持者",则答案就是 LCA
// 求 LCA 的暴力写法(沿链上跳,沿链打标记)
int lca(int u, int v) {
bool on[305] = {false};
for (int x = u; ; x = f[x]) { on[x] = true; if (x == 0) break; }
for (int y = v; ; y = f[y]) { if (on[y]) return y; if (y == 0) break; }
return 0;
}
// 注意 f[i] 不一定小于 i,所以不能假设"编号小的层级浅"你有 10^9 个牛棚,从左到右一字排开。你希望把 n 头牛安置到牛棚里。麻烦的是,你的牛很好斗,如果他们附近有其他的牛,他们就会不安分地去挑事。其中,第 i 头牛的攻击范围是 (a_i, b_i),这意味着,如果他的左边 a_i 个牛棚或者右边 b_i 个牛棚有其他牛,它就会去挑事。
你想留下一段连续的牛棚,并把其他牛棚都卖掉。请问您最少需要留下多少牛棚,才能保证至少存在一种方案能够把所有的 n 头牛都安置进剩余的牛棚里,且没有牛会挑事?
第一行一个正整数 n。
第二行 n 个正整数 a_1, a_2, … a_n。
第三行 n 个正整数 b_1, b_2, … b_n。
输出一行一个整数表示答案。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 2 1 2 1 2 | 4 |
| 2 | 3 1 2 3 3 2 1 | 7 |
留下第 1、2、3、4 个牛棚,并在第 1、4 两个牛棚分别放下两头牛。
数据规模与约定
- 对 20% 的数据,保证 n = 2。
- 另有 20% 的数据,保证 n = 3。
- 对 80% 的数据,保证 n ≤q 8。
- 对于所有的测试数据,保证 1 ≤q n ≤q 9,1 ≤q a_i, b_i ≤q 10^3。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
有 10⁹ 个牛棚一字排开。要把 n 头牛安置进去。第 i 头牛的攻击范围是 (aᵢ, bᵢ):若它的左边 aᵢ 个牛棚内或右边 bᵢ 个牛棚内有其他牛,它就会挑事。
要留下一段连续的牛棚(其余卖掉),使得能安置所有 n 头牛且无牛挑事。求最少需要留下多少个牛棚。
💡人话翻译:n ≤ 9 这个数据范围是明确提示——直接枚举所有排列(9! = 362880)即可。
对每种排列,从左到右依次放牛,相邻两头牛之间需要的最小间距是max(a_右牛 + 1, b_左牛 + 1)。
把所有间距加起来再加 1,就是这种排列需要的跨度;取所有排列中的最小值就是答案。
🔍 关键词提取
全排列枚举相邻间隙跨度计算取最小值
已知条件
项目说明
输入第一行 n;第二行 a₁…aₙ;第三行 b₁…bₙ
输出最少留下的牛棚数
数据范围1 ≤ n ≤ 9
参数范围1 ≤ aᵢ, bᵢ ≤ 10³
目标最小跨度(连续牛棚数量)
需要解决的问题
两头牛之间要隔多远?设左边是牛 X、右边是牛 Y,距离为 d(牛棚编号差):X 要求 d > b_X、Y 要求 d > a_Y,所以 d ≥ max(b_X + 1, a_Y + 1)
为什么只需要考虑相邻两头?因为一旦相邻的都满足,更远的牛距离更大,自然更满足
怎么求最小跨度?枚举排列,每种排列按最小间距依次放置,跨度 = 最后一个位置 − 第一个位置 + 1
🧠 模型
留下连续一段牛棚
牛可以任意顺序放
使跨度最小
n ≤ 9 → 可以全排列
📐 间距公式
左牛 X、右牛 Y
X 要求 d > b_X
Y 要求 d > a_Y
d = max(b_X + 1, a_Y + 1)
🔁 计算
对每个排列贪心地最小放置
位置从 0 开始累加间距
跨度 = 末位 − 首位 + 1
取所有排列的最小值
⚠️ 易错点
把间距写成 max(a_X+1, b_Y+1)(左右搞反)
忘记最后 + 1
用 int 存放但实际范围很小(安全)
漏掉 n = 1 的情况
只有两种排列,都试一遍。
1
排列 (1, 2):牛 1 在左、牛 2 在右
间距要求 d ≥ max(b₁ + 1, a₂ + 1)
= max(1 + 1, 2 + 1) = max(2, 3) = 3
放置:p₁ = 1,p₂ = 1 + 3 = 4
跨度 = 4 − 1 + 1 = 4
跨度 4
2
排列 (2, 1):牛 2 在左、牛 1 在右
d ≥ max(b₂ + 1, a₁ + 1) = max(3, 2) = 3
放置:p₂ = 1,p₁ = 4
跨度 = 4
跨度 4
最少 4 个牛棚 ✓
🔑验证样例解释:题目说"留下第 1、2、3、4 个牛棚,在第 1、4 个牛棚放牛"。
检查:两头牛相距 3,牛 1(在左)的右攻击范围 b₁ = 1 < 3 ✓ 不挑事;牛 2(在右)的左攻击范围 a₂ = 2 < 3 ✓ 不挑事。而如果只留 3 个牛棚(间距 2),a₂ = 2 不满足"大于 2",就会挑事。
🧮 样例 2:n = 3,a = [1, 2, 3],b = [3, 2, 1]
三种牛的参数呈"镜像":牛1(1,3)、牛2(2,2)、牛3(3,1)。共 6 种排列,我们只算最优的那一种。
1
试排列 (3, 2, 1)
牛 3 在左、牛 2 中间、牛 1 在右
第 1 个间距(3→2):max(b₃+1, a₂+1) = max(2, 3) = 3
第 2 个间距(2→1):max(b₂+1, a₁+1) = max(3, 2) = 3
位置:1、4、7
跨度 = 7 − 1 + 1 = 7
跨度 7
2
试排列 (1, 2, 3)
第 1 个间距(1→2):max(b₁+1, a₂+1) = max(4, 3) = 4
第 2 个间距(2→3):max(b₂+1, a₃+1) = max(3, 4) = 4
位置:1、5、9 → 跨度 9
跨度 9(更差)
📊 按"攻击范围大者居中"的思路理解
牛a(左)b(右)特点
113右攻击范围大
222左右对称
331左攻击范围大
把"左攻击大的牛放右边、右攻击大的牛放左边",间距才最省
答案 7 ✓
⚠️注意"相邻间距取 max"的方向:左边那头牛贡献的是它的 b(右攻击范围),右边那头牛贡献的是它的 a(左攻击范围)。
写反了就完全错了——这是本题最容易出的错。
记忆方法:"两头牛互相看着对方",所以左边牛的右范围、右边牛的左范围都要被尊重。
🟢 全排列枚举(推荐) 推荐
枚举 n! 种顺序,每种线性计算跨度,取最小
时间 O(n! × n)
n = 9 时约 3.3 × 10⁶
代码 25 行(可用 next_permutation)
简单直观
💡实现:把 0…n−1 放进一个数组,用 next_permutation 遍历所有排列;对每个排列从左到右累加间距pos += max(b[left]+1, a[right]+1),最后跨度 = pos_end − 1 + 1。n ≤ 9 是题目给的最强提示:看到 9 就该想到全排列。
🟠 状压 DP
dp[mask][last] 表示已放 mask 这些牛、最后一头是 last 时的最小左端位置
时间 O(2ⁿ × n²)
n = 9 时约 4 × 10⁴(更快)
代码更复杂
本题没必要
⚠️什么时候值得用:如果 n 放大到 15 ~ 20,全排列(15! ≈ 1.3 × 10¹²)就不可行了,必须用状压 DP。但本题 n ≤ 9,全排列已经足够。
📈 性能对比
方案复杂度(n = 9)代码量
全排列约 3.3 × 10⁶约 25 行
状压 DP约 4 × 10⁴约 40 行
第一行输入 a 数组,第二行输入 b 数组,程序会枚举所有排列并找出最小跨度。
输入数据1 2 3
3 2 1
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int a[12], b[12];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
vector<int> p(n);
for (int i = 0; i < n; i++) p[i] = i; // 牛的编号 0 ~ n-1
int ans = INT_MAX;
do {
// 从左到右依次按"最小间距"放置
int pos = 1; // 第一头牛放在 1 号棚
for (int i = 0; i + 1 < n; i++) {
int l = p[i], r = p[i + 1];
// 左牛的右攻击范围、右牛的左攻击范围,都要留够
pos += max(b[l] + 1, a[r] + 1);
}
ans = min(ans, pos); // pos 就是"S 到 E 的跨度"
} while (next_permutation(p.begin(), p.end()));
printf("%d\n", ans);
return 0;
}
🔑为什么间距是 max(b[左] + 1, a[右] + 1)?设两头牛的位置差为 d(牛棚编号之差)。题目说"若左边 b 个牛棚内有牛就挑事"——所以要求 d > b[左],即 d ≥ b[左] + 1;同理右边那头要求 d ≥ a[右] + 1。
两个条件都要满足,所以取 max。注意是"左牛的 b"配"右牛的 a",方向千万不能反。
📖 关键几行怎么看
代码作用为什么这样写
vector<int> p(n)排列数组存牛编号,配合 next_permutation
int pos = 1起点第一头牛放在 1 号牛棚
pos += max(b[l]+1, a[r]+1)累加间距左牛 b、右牛 a
ans = min(ans, pos)取最小pos 正好等于跨度(末 − 首 + 1)
next_permutation枚举排列自动遍历全部 n! 种
⚠️四个坑:① 间距写成 max(a[左]+1, b[右]+1)(方向反了);② 忘记 +1("范围内有牛就挑事"是严格不等式);③ ans 初值取 0(应取一个很大的数);④ next_permutation 要求初始数组已升序。
写完程序后,用这些数据自查一遍:
输入答案考察点
2
1 2
1 24题面样例 1
3
1 2 3
3 2 17题面样例 2(最优顺序 3 → 2 → 1)
1
5
51只有一头牛,1 个牛棚足够
2
1 1
1 13间距 = max(1+1, 1+1) = 2 → 跨度 3
3
1 1 1
1 1 15三头牛各隔 2:位置 1、3、5 → 跨度 5
✅自查清单:① 间距方向对吗?② 加 1 了吗?③ 枚举了全部排列吗?
🚨 易错点清单
⚠️间距方向反:必须是"左牛的 b"和"右牛的 a",写成 a[左]、b[右] 就错了。
⚠️忘记 +1:"b 个牛棚内有牛就挑事"意味着距离必须 > b。
⚠️排列未升序初始化:next_permutation 需要初始有序,否则会漏掉排列。
时间复杂度
O(n! × n)
空间复杂度
O(n)
n 最大
9
运算量
约 3.3 × 10⁶
时间怎么算的?
共 n! 种排列
每种排列线性扫描 n 次
n = 9 时 362880 × 9 ≈ 3.3 × 10⁶
空间都用在哪?
只需存 a、b 数组和一个排列数组。
✅ 约 330 万次操作,瞬间完成。n ≤ 9 这个"异常小"的范围就是题目的解法提示。
// 全排列枚举模板
vector<int> p(n);
iota(p.begin(), p.end(), 0); // 0, 1, 2, ..., n-1(必须升序)
do {
// 对排列 p 做计算
} while (next_permutation(p.begin(), p.end()));
// 本题的跨度计算
int span(const vector<int>& p, int a[], int b[]) {
int n = p.size(), pos = 1;
for (int i = 0; i + 1 < n; i++)
pos += max(b[p[i]] + 1, a[p[i+1]] + 1); // 左牛b、右牛a
return pos;
}
// 如果 n 变大(15 ~ 20):改用状压 DP
// dp[mask][last] = 放完 mask 这些牛、最后放 last 时"最右端位置"的最小值
// 转移:dp[mask | (1<<j)][j] = min(dp[mask][last] + gap(last, j))
// 竞赛经验:数据范围就是解法提示
// n <= 9 -> 全排列 / 搜索
// n <= 20 -> 状压 DP
// n <= 500 -> O(n^3) 区间 DP 或 Floyd
// n <= 1e5 -> O(n log n)
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
全排列枚举next_permutationn ≤ 9 的所有排列问题
相邻约束只需满足相邻,远处自动满足排列中的局部约束
数据范围即提示n 小 → 枚举竞赛读题的第一反应
🌟思考题:如果 n 放大到 15,全排列(15! ≈ 1.3 × 10¹²)就不可行了,你会怎么做?(提示:用状压 DP——dp[mask][last] 表示"已经放了 mask 这些牛、最后一头是 last"时最右端位置的最小值,转移时枚举下一头牛即可,复杂度 O(2ⁿ × n²),n = 15 时约 700 万 ✓。"n 小用枚举、n 中用状压"是排列类问题的通用升级路线。)
#include <bits/stdc++.h>
using namespace std;
int a[12], b[12];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
vector<int> p(n);
for (int i = 0; i < n; i++) p[i] = i; // 牛的编号 0 ~ n-1
int ans = INT_MAX;
do {
// 从左到右依次按"最小间距"放置
int pos = 1; // 第一头牛放在 1 号棚
for (int i = 0; i + 1 < n; i++) {
int l = p[i], r = p[i + 1];
// 左牛的右攻击范围、右牛的左攻击范围,都要留够
pos += max(b[l] + 1, a[r] + 1);
}
ans = min(ans, pos); // pos 就是"S 到 E 的跨度"
} while (next_permutation(p.begin(), p.end()));
printf("%d\n", ans);
return 0;
}// 全排列枚举模板
vector<int> p(n);
iota(p.begin(), p.end(), 0); // 0, 1, 2, ..., n-1(必须升序)
do {
// 对排列 p 做计算
} while (next_permutation(p.begin(), p.end()));
// 本题的跨度计算
int span(const vector<int>& p, int a[], int b[]) {
int n = p.size(), pos = 1;
for (int i = 0; i + 1 < n; i++)
pos += max(b[p[i]] + 1, a[p[i+1]] + 1); // 左牛b、右牛a
return pos;
}
// 如果 n 变大(15 ~ 20):改用状压 DP
// dp[mask][last] = 放完 mask 这些牛、最后放 last 时"最右端位置"的最小值
// 转移:dp[mask | (1<<j)][j] = min(dp[mask][last] + gap(last, j))
// 竞赛经验:数据范围就是解法提示
// n <= 9 -> 全排列 / 搜索
// n <= 20 -> 状压 DP
// n <= 500 -> O(n^3) 区间 DP 或 Floyd
// n <= 1e5 -> O(n log n)②编程打卡 · 点一下就能勾选
- 完成 P10109《工作沟通》,跑通全部样例
- 完成 P10377《好斗的牛》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
广度优先搜索 BFS 与图论
①本日知识点 · 广度优先搜索 BFS 与图论
BFS 用队列,第一次到达即最短;建图别漏反向边。
本组 4 道题全部来自 GESP 真题,按「广度优先搜索 BFS 与图论」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
小 A 想在这棵树上漫步。具体来说,小 A 会从树上的某个结点出发,每一步可以移动到与当前结点相邻的结点,并且小 A 只会在偶数步(可以是零步)后结束漫步。
现在小 A 想知道,对于树上的每个结点,从这个结点出发开始漫步,经过偶数步能结束漫步的结点有多少个(可以经过重复的节点)。
接下来 n-1 行,每行两个整数 u_i,v_i,表示树上有⼀条连接结点 u_i 和结点 v_i 的边。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 1 3 2 3 | 2 2 1 |
| 2 | 4 1 3 3 2 4 3 | 3 3 1 3 |
对于所有测试点,保证 1≤q n≤q 2× 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
一棵 n 个结点的树。小 A 从某结点出发,每步走到相邻结点,只在偶数步(含 0 步)后结束漫步。对每个结点 i,求"从 i 出发、经过偶数步能结束漫步的结点有多少个"(中途可以重复经过结点)。
💡人话翻译:关键结论一句话——从 s 出发走偶数步能到 u,当且仅当 s 与 u 的距离为偶数。
原因是树是二分图:任何一条从 s 到 u 的路径长度都与 dist(s,u) 同奇偶;而绕路(来回走)只会增加偶数长度,不会改变奇偶性。
于是只需统计每个结点到根的距离奇偶,用两类计数数组就能 O(1) 回答每个结点。
🔍 关键词提取
树的二分图性质距离奇偶性深度统计O(n) 树遍历
已知条件
项目说明
输入第一行 n;随后 n−1 行每行 uᵢ、vᵢ
输出n 个整数,第 i 个是结点 i 的答案
数据范围1 ≤ n ≤ 2 × 10⁵
步数只能是 0、2、4、6…(偶数)
可否重复经过可以(但不影响结论)
需要解决的问题
为什么"可重复经过"不影响结论?因为来回走一步再走回来会多花 2 步,只会让长度增加偶数,奇偶性不变
怎么统计?对每个结点求到根的深度,按深度奇偶分成两类;答案是与自身同类结点的个数
为什么?dist(s,u) = dep(s) + dep(u) − 2·dep(LCA),所以奇偶性只取决于 dep(s) + dep(u)
🧠 核心结论
树是二分图
任意路径长度与 dist 同奇偶
走回头路只增加偶数长度
所以偶数步可达 = 距离为偶数
📊 统计方法
求每个结点到根的深度 dep
按 dep 的奇偶分两类
cnt[0] = 深度为偶的个数
cnt[1] = 深度为奇的个数
✅ 答案
dist(s,u) 偶 ⟺ dep(s)、dep(u) 同奇偶
所以答案 = dep(s) 所在类的个数
每个结点 O(1)
输出 n 个数
⚠️ 易错点
用 DFS 递归(n 大可爆栈)
以为要真的模拟走偶数步
把"可达的步数"和"可达的结点"混淆
根结点深度算错(应为 0)
边:1–3、2–3。所以 3 是中心,1 和 2 是叶子。
1
任选一个结点当根,求深度
以结点 1 为根:
dep(1) = 0(偶)
dep(3) = 1(奇)
dep(2) = 2(偶)
深度 = {0, 1, 2}
2
按奇偶分类计数
深度为偶:结点 1、2 → cnt[0] = 2
深度为奇:结点 3 → cnt[1] = 1
cnt = {偶:2, 奇:1}
3
逐个求答案
结点 1(偶):cnt[0] = 2
结点 2(偶):cnt[0] = 2
结点 3(奇):cnt[1] = 1
✅ 输出 "2 2 1"
📊 手工验证结点 1
目标结点dist(1, ·)奇偶偶数步可达?
10偶✅(0 步,原地)
22(1→3→2)偶✅(2 步)
31(1→3)奇✗(只能 1、3、5… 步)
结点 1 的答案是 2 ✓ 与输出一致
🔑注意"0 步"也算:题目说"只在偶数步(可以是零步)后结束漫步",所以出发结点自己也算一个可达结点。这解释了为什么答案里总有 cnt[自身类] 至少为 1。
🧮 样例 2:4 个结点的星形树
边:1–3、3–2、4–3。这是以 3 为中心的星形(3 连着 1、2、4)。
1
深度与分类
以结点 1 为根:
dep(1) = 0(偶)
dep(3) = 1(奇)
dep(2) = 2(偶)
dep(4) = 2(偶)
cnt[偶] = 3(结点 1、2、4),cnt[奇] = 1(结点 3)
cnt = {偶:3, 奇:1}
2
逐个求答案
结点 1(偶)→ 3
结点 2(偶)→ 3
结点 3(奇)→ 1
结点 4(偶)→ 3
✅ 输出 "3 3 1 3"
输出 3 3 1 3 ✓ 与样例一致
💡 直观理解
星形树很直观:从中心 3 出发,走 1 步就到某个叶子(奇数步,不允许结束),再走 1 步必须回到 3 或去别的叶子(2 步,允许)。所以从中心只能回到中心(1 个结点);而从叶子出发,2 步后可以落在任意叶子或根上(3 个结点)。这与结论完全吻合。
⚠️不要试图"模拟走偶数步":步数没有上限,逐层 BFS 会超时。本题的解法是"一步到位"的数学结论,这也是它作为 6 级题的核心考点——识别出"奇偶性"这个不变量。
🟢 深度奇偶统计(推荐) 推荐
一次遍历求所有结点深度,按奇偶分类计数,直接得答案
时间 O(n)
n = 2 × 10⁵ 时约 2 × 10⁵
代码 20 行
空间 O(n)
💡答案公式:ans[s] = cnt[dep(s) % 2],其中 cnt[0] 是深度为偶的结点数、cnt[1] 是深度为奇的结点数。一行就能算完,不需要任何模拟。
🟠 模拟"走 0、2、4、… 步"
从每个结点 BFS 若干层,标记所有偶数步可达点
步数无上限
从每个结点做 BFS:O(n²)
n = 2 × 10⁵ 时 4 × 10¹⁰
必然超时
⚠️为什么不能用模拟:因为"偶数步"没有上限,要枚举到多少步才停?而实际上可达集合很快就"稳定"了——这个"稳定"正对应"距离奇偶性"这个不变量。
📈 性能对比
方案复杂度可行性
奇偶统计O(n)✅ 稳过
逐结点模拟O(n²)❌ 超时
第一行输入 n,随后 n−1 行输入每条边,程序会给出每个结点的答案。
输入数据3
1 3
2 3
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int dep[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
// 迭代 BFS 求深度(避免 n 大且为链时的递归爆栈)
for (int i = 1; i <= n; i++) dep[i] = -1;
dep[1] = 0;
queue<int> q;
q.push(1);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : g[u]) {
if (dep[v] == -1) {
dep[v] = dep[u] + 1;
q.push(v);
}
}
}
// 按深度奇偶分类计数
int cnt[2] = {0, 0};
for (int i = 1; i <= n; i++) cnt[dep[i] % 2]++;
// 每个结点的答案 = 与它深度同奇偶的结点个数
for (int i = 1; i <= n; i++)
printf("%d%c", cnt[dep[i] % 2], i == n ? '\n' : ' ');
return 0;
}
🔑为什么答案是"深度同奇偶的结点数"?对树上任意两点 s、u,距离公式是dist(s,u) = dep(s) + dep(u) − 2·dep(LCA)。其中 2·dep(LCA) 必为偶数,所以 dist(s,u) 的奇偶性只由 dep(s) + dep(u) 决定——也就是"两点深度是否同奇偶"。
注意这里的"根"可以任选(我们选了结点 1),因为奇偶性的结论与根的选取无关。
📖 关键几行怎么看
代码作用为什么这样写
dep[1] = 0根的深度约定根深度为 0(偶)
queue<int> q迭代 BFS避免递归爆栈
cnt[dep[i] % 2]++分类计数按深度奇偶各统计一类
cnt[dep[i] % 2]答案与自身同奇偶类的结点数
⚠️四个坑:① 用递归 DFS(n = 2 × 10⁵ 且为链时爆栈);② 以为要真的模拟走偶数步;③ 把答案理解成"经过偶数步的步数"(题目问的是结点个数);④ 忘记 dep[1] = 0,导致整棵树的奇偶全反。
写完程序后,用这些数据自查一遍:
输入答案考察点
3
1 3 / 2 32 2 1题面样例 1
4
1 3 / 3 2 / 4 33 3 1 3题面样例 2(星形)
11只有一个结点,0 步到达自己
2
1 21 1两点距离为 1(奇),只能各自到自身
3
1 2 / 2 32 1 2链 1–2–3:深度 0、1、2,cnt = {偶:2, 奇:1}
✅自查清单:① 用 BFS 求深度吗?② 按深度奇偶分类了吗?③ 答案取同类计数吗?
🚨 易错点清单
⚠️递归 DFS:n = 2 × 10⁵ 的链状数据会爆栈,应用 BFS 或迭代栈。
⚠️真的模拟走偶数步:步数无上限,应该用"距离奇偶性"这个结论。
⚠️答案含义理解错:问的是"可达的结点个数",不是步数。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
2 × 10⁵
运算量
约 2 × 10⁵
时间怎么算的?
BFS 遍历每个结点一次 O(n)
分类计数与输出各 O(n)
合计 O(n)
空间都用在哪?
邻接表需要存 2(n−1) 条边,加上深度数组。
✅ 约 20 万次操作,瞬间完成。本题的关键是"想到奇偶性",而不是算法本身。
// 核心结论汇总
// 树是二分图:可按"深度奇偶"把结点分成两个独立集
// 从 s 到 u 的任意路径长度 ≡ dist(s, u) (mod 2)
// 走偶数步可达的结点集合 = { u : dist(s,u) 为偶数 } = 与 s 同色的结点集
// 答案[s] = cnt[dep[s] % 2]
// 树上的"奇偶分层"技巧在很多题里出现
// - 判断能否用偶数步/奇数步到达
// - 树上染色(相邻结点异色)
// - 树上博弈(走偶数步结束)
// 求树上所有结点深度的迭代 BFS 模板
queue<int> q; dep[root] = 0; q.push(root);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : g[u]) if (dep[v] == -1) { dep[v] = dep[u] + 1; q.push(v); }
}
// 若真的要判断"能否走恰好 k 步到达"
// 由于可以来回走,只要 dist(s,u) <= k 且同奇偶即可
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
二分图性质相邻异色、同色距离为偶树上所有"步数奇偶"问题
深度奇偶分层一次 BFS 得到两类树上染色、博弈、可达性
距离公式dep(u)+dep(v)−2·dep(LCA)树上两点距离的奇偶判断
🌟思考题:如果题目改成"只在奇数步后结束漫步",答案会怎么变?(提示:正好互换两类——奇数步可达 ⟺ 距离为奇数 ⟺ 深度不同奇偶,所以 ans[s] = cnt[1 − dep[s] % 2]。这类"奇偶反转"的题只要改一个下标,但必须真正理解背后的二分图原理才不会写错。)
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int dep[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
// 迭代 BFS 求深度(避免 n 大且为链时的递归爆栈)
for (int i = 1; i <= n; i++) dep[i] = -1;
dep[1] = 0;
queue<int> q;
q.push(1);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : g[u]) {
if (dep[v] == -1) {
dep[v] = dep[u] + 1;
q.push(v);
}
}
}
// 按深度奇偶分类计数
int cnt[2] = {0, 0};
for (int i = 1; i <= n; i++) cnt[dep[i] % 2]++;
// 每个结点的答案 = 与它深度同奇偶的结点个数
for (int i = 1; i <= n; i++)
printf("%d%c", cnt[dep[i] % 2], i == n ? '\n' : ' ');
return 0;
}// 核心结论汇总
// 树是二分图:可按"深度奇偶"把结点分成两个独立集
// 从 s 到 u 的任意路径长度 ≡ dist(s, u) (mod 2)
// 走偶数步可达的结点集合 = { u : dist(s,u) 为偶数 } = 与 s 同色的结点集
// 答案[s] = cnt[dep[s] % 2]
// 树上的"奇偶分层"技巧在很多题里出现
// - 判断能否用偶数步/奇数步到达
// - 树上染色(相邻结点异色)
// - 树上博弈(走偶数步结束)
// 求树上所有结点深度的迭代 BFS 模板
queue<int> q; dep[root] = 0; q.push(root);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : g[u]) if (dep[v] == -1) { dep[v] = dep[u] + 1; q.push(v); }
}
// 若真的要判断"能否走恰好 k 步到达"
// 由于可以来回走,只要 dist(s,u) <= k 且同奇偶即可现在 A 国需要从首都向各个城市运送货物。具体来说,满载货物的车队会从首都开出,经过一座城市时将对应的货物送出,因此车队需要经过所有城市。A 国希望你设计一条路线,在从首都出发经过所有城市的前提下,最小化经过的道路长度总和。注意一座城市可以经过多次,车队最后可以不返回首都。
接下来 n-1 行,每行三个正整数 u_i,v_i,l_i,表示一条双向道路连接编号为 u_i,v_i 的两座城市,道路长度为 l_i。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 2 6 1 3 1 3 4 5 | 18 |
| 2 | 7 1 2 1 2 3 1 3 4 1 7 6 1 6 5 1 5 1 1 | 9 |
对于另外 30% 的测试点,保证仅与一条双向道路连接的城市恰有两座。
对于所有测试点,保证 1 ≤ n ≤ 10^5,1 ≤ u_i,v_i ≤ n,1 ≤ l_i ≤ 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
A 国有 n 座城市(1 号为首都),由 n−1 条双向道路连成一棵树,第 i 条道路连接 uᵢ、vᵢ,长度为 lᵢ。车队从首都出发,经过每座城市时送出货物,要求经过所有城市,且最后不必返回首都。求经过的道路长度总和的最小值。
💡人话翻译:这是"树上遍历"的经典结论题。一条边至少要"下去、回来"各一次,所以先按每条边走两遍来算:2 × 总边长。
但最后那段路不需要走回头路——所以我们把最深的那条根到叶路径"省一次"。
答案就是 2 × Σl − maxDist。
🔍 关键词提取
树上遍历欧拉路径最长根叶路径DFS
已知条件
项目说明
输入第一行 n;随后 n−1 行每行 uᵢ、vᵢ、lᵢ
输出经过道路长度总和的最小值
数据范围1 ≤ n ≤ 10⁵
边长1 ≤ lᵢ ≤ 10⁹
起点/终点起点固定为首都市 1,终点任意
需要解决的问题
为什么每条边至少走两次?因为车队从根出发,要遍历完某棵子树再"回到"分叉点才能去别的分支——下去的边必须再上来一次
哪条边可以只走一次?只有"从根到最终停留点"这条路径上的边能少走一次(因为终点的祖先们不需要再往回走)
怎么让省得最多?让终点尽量远——选距离根最远的结点作为终点
🧠 下界分析
每条边至少走 2 次
因为要下去还要回来
总长至少 2 × Σl
这是基准
✂️ 可以省什么
最后停留点沿途的边只走一次
所以能省下"根到终点"的距离
省得越多越好
所以终点取最远的叶子
✅ 最终公式
答案 = 2 × Σl − maxDist
maxDist = max 根到各点距离
起点固定为根
终点可任选
⚠️ 易错点
写成 2×Σl(忘了可以省)
用 int(可达 10¹⁴)
递归 DFS 爆栈
误以为要返回起点
道路:1–2 长 6、1–3 长 1、3–4 长 5。
1
第 1 步:总边长
Σl = 6 + 1 + 5 = 12
若全部走两遍:2 × 12 = 24
基准 24
2
第 2 步:各点到根(城市 1)的距离
城市 1:0
城市 2:走边 1–2 → 6
城市 3:走边 1–3 → 1
城市 4:1–3 → 1,再 3–4 → 1 + 5 = 6
距离 = {0, 6, 1, 6}
3
第 3 步:取最大值并相减
maxDist = max(0, 6, 1, 6) = 6
答案 = 24 − 6 = 18
✅ 答案 18
📊 计算汇总
城市到根距离备注
1(根)0起点
26直接相连
31直接相连
461 → 3 → 4 = 1 + 5 = 6,是最远的之一
24 − 6 = 18 ✓
🔑注意"城市 2 和城市 4 都离根 6",选哪个当终点都行,答案都是 18。这说明"最远距离相同"时方案不唯一,但答案唯一。
🧮 样例 2:一条"折返的链"
道路:1–2、2–3、3–4、7–6、6–5、5–1,长度都是 1。
1
总边长
共 6 条边,每条长 1
Σl = 6 → 2 × 6 = 12
基准 12
2
各点到根的距离
到 2:1;到 3:2;到 4:3
到 5:1;到 6:2;到 7:3
所以这棵树其实是"两条长度为 3 的链"挂在一起
maxDist = 3
3
相减
答案 = 12 − 3 = 9
✅ 答案 9
可以从 1 走到 4(或 7),把另一条链"完整走一个来回"
⚠️注意样例 2 的形状:题目给的边顺序是打乱的(先出现 7–6、6–5、5–1,再看到 1–2、2–3、3–4),所以不能"按输入顺序"建树,必须用邻接表通用地存图。这是树类题目的常见陷阱。
🟢 结论公式(推荐) 推荐
2 × 总边长 − 根到最远点的距离
时间 O(n)
一次 DFS/BFS 即可
代码 25 行
有严格的下界证明
💡严谨的说法:每条边至少走两次(除非它在"最后不回头的路径"上),所以下界是 2Σl − maxDist;而这个下界可以构造达到——以最远点为终点做一次深度优先遍历,沿途其他分支都走"来回"即可。
🟠 搜索所有遍历顺序
枚举访问顺序 / 状压 DP 找最短遍历路径
复杂度指数级
n = 10⁵ 完全不可行
只能处理 n ≤ 8 的测试点
属于"杀鸡用牛刀还砍不动"
⚠️为什么不能搜索:"遍历所有结点的最短路"在一般图上是 NP 难问题,但在树上有简洁结论。树的结构特殊性正是本题能 O(n) 求解的根本原因。
📈 性能对比
方案复杂度可行性
结论公式O(n)✅ 稳过
搜索/状压指数级❌ 不可行
第一行输入 n,随后 n−1 行输入每条边(u v 长度)。
输入数据4
1 2 6
1 3 1
3 4 5
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
struct Edge { int to; long long w; };
vector<Edge> g[100005];
long long dis[100005];
bool vis[100005];
int main() {
int n;
scanf("%d", &n);
long long sum = 0;
for (int i = 0; i < n - 1; i++) {
int u, v; long long l;
scanf("%d %d %lld", &u, &v, &l);
g[u].push_back({v, l});
g[v].push_back({u, l}); // 双向道路,两边都要存
sum += l; // 每条边都会被算进"两倍"里
}
// 用栈做迭代 DFS,避免 n = 10^5 且是链时递归爆栈
stack<int> st;
st.push(1);
dis[1] = 0;
vis[1] = true;
long long maxDist = 0;
while (!st.empty()) {
int u = st.top(); st.pop();
maxDist = max(maxDist, dis[u]);
for (Edge e : g[u]) {
if (!vis[e.to]) {
vis[e.to] = true;
dis[e.to] = dis[u] + e.w;
st.push(e.to);
}
}
}
printf("%lld\n", 2 * sum - maxDist);
return 0;
}
🔑为什么要用 2 * sum - maxDist 而不是直接累加?因为遍历顺序无穷多,但答案有闭式结论:所有边至少走 2 次(下去回来),唯独"最后不回头的路径"上的边只走 1 次。为了让省的更多,就让这条路径最长——即终点选最远点。
这种"先给出下界、再构造达到下界"的思路是竞赛里证明结论的标准手法。
📖 关键几行怎么看
代码作用为什么这样写
g[u].push_back({v, l}); g[v].push_back({u, l});存双向边道路是双向的
sum += l累加总边长每条边计入"两倍"的基准
stack<int> st迭代 DFS避免递归爆栈
maxDist = max(maxDist, dis[u])记录最远距离它就是可以省下来的那部分
2 * sum - maxDist答案结论公式
⚠️四个坑:① 只写 2 * sum(忘了终点可以不回头);② 用 int(n × lᵢ 可达 10⁵ × 10⁹ = 10¹⁴);③ 用递归 DFS(n 达 10⁵ 时链状数据会爆栈);④ 只存单向边(导致有些城市遍历不到,dis 仍是初值)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
1 2 6 / 1 3 1 / 3 4 518题面样例 1
7
1 2 1 / 2 3 1 / 3 4 1 / 7 6 1 / 6 5 1 / 5 1 19题面样例 2(两条链拼在一起)
10只有首都,不用走路
2
1 2 55一条边:下去就行,不用回来
3
1 2 4 / 1 3 412两条等长分支:走完一条回来再去另一条 → 4×2 + 4 = 12
✅自查清单:① 累加了 Σl 吗?② 求了最远距离吗?③ 用 long long 吗?
🚨 易错点清单
⚠️忘记减 maxDist:终点可以不返回,所以要减掉"根到最远点"的距离。
⚠️用 int:总长可达 10¹⁴,必须用 long long。
⚠️递归 DFS:n = 10⁵ 的链状数据会爆栈,用迭代栈。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
运算量
约 10⁵
时间怎么算的?
读入并建邻接表 O(n)
DFS 遍历每个结点一次 O(n)
合计 O(n)
空间都用在哪?
邻接表需要存 2(n−1) 条边,加上 dis、vis 数组。
✅ 约 10 万次操作,瞬间完成。本题的关键是想到结论,而不是算法本身。
// 树上遍历类问题的常见结论
// 1. 从根出发、走遍所有点、最后回到根:最小长度 = 2 × 总边长
// 2. 从根出发、走遍所有点、最后不必回:最小长度 = 2 × 总边长 − 最远点距离
// 3. 从任意点出发、走遍所有点、最后不必回:
// 2 × 总边长 − 树的直径
// (第 3 条是更一般的结论,直径用两次 DFS/BFS 求)
// 求树的直径(两次 BFS)
// (1) 从任意点出发 BFS,找到最远的点 A
// (2) 从 A 出发 BFS,找到最远的点 B,AB 距离即直径
// 迭代 DFS 模板(避免爆栈)
stack<int> st; st.push(root); vis[root] = true;
while (!st.empty()) {
int u = st.top(); st.pop();
for (auto e : g[u]) if (!vis[e.to]) { vis[e.to] = true; st.push(e.to); }
}
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
树上遍历结论2 × 总边长 − 可省路径所有"走遍全树"的最短路问题
迭代 DFS用栈代替递归n 大且可能链状的树题
直径两次 BFS 求最长路径"任意起点、最后不必回"的遍历
🌟思考题:如果题目改成"车队最后必须回到首都",答案会怎样?(提示:就不能省任何东西了——每条边都必须"下去再上来",所以答案就是 2 × 总边长。看样例 1:2 × 12 = 24。"终点是否必须回到出发点"直接决定答案公式,这是这类题最需要读清的条件。)
#include <bits/stdc++.h>
using namespace std;
struct Edge { int to; long long w; };
vector<Edge> g[100005];
long long dis[100005];
bool vis[100005];
int main() {
int n;
scanf("%d", &n);
long long sum = 0;
for (int i = 0; i < n - 1; i++) {
int u, v; long long l;
scanf("%d %d %lld", &u, &v, &l);
g[u].push_back({v, l});
g[v].push_back({u, l}); // 双向道路,两边都要存
sum += l; // 每条边都会被算进"两倍"里
}
// 用栈做迭代 DFS,避免 n = 10^5 且是链时递归爆栈
stack<int> st;
st.push(1);
dis[1] = 0;
vis[1] = true;
long long maxDist = 0;
while (!st.empty()) {
int u = st.top(); st.pop();
maxDist = max(maxDist, dis[u]);
for (Edge e : g[u]) {
if (!vis[e.to]) {
vis[e.to] = true;
dis[e.to] = dis[u] + e.w;
st.push(e.to);
}
}
}
printf("%lld\n", 2 * sum - maxDist);
return 0;
}// 树上遍历类问题的常见结论
// 1. 从根出发、走遍所有点、最后回到根:最小长度 = 2 × 总边长
// 2. 从根出发、走遍所有点、最后不必回:最小长度 = 2 × 总边长 − 最远点距离
// 3. 从任意点出发、走遍所有点、最后不必回:
// 2 × 总边长 − 树的直径
// (第 3 条是更一般的结论,直径用两次 DFS/BFS 求)
// 求树的直径(两次 BFS)
// (1) 从任意点出发 BFS,找到最远的点 A
// (2) 从 A 出发 BFS,找到最远的点 B,AB 距离即直径
// 迭代 DFS 模板(避免爆栈)
stack<int> st; st.push(root); vis[root] = true;
while (!st.empty()) {
int u = st.top(); st.pop();
for (auto e : g[u]) if (!vis[e.to]) { vis[e.to] = true; st.push(e.to); }
}小杨想知道 q 次操作全部完成之后每个节点的颜色。
第二行 (n-1) 个正整数,第 i(1≤ i≤ n-1)个数表示编号为 (i+1) 的节点的父亲节点编号,数据保证是一棵二叉树。
第三行一个长度为 n 的 \texttt{01} 串,从左到右第 i(1≤ i≤ n)位如果为 \texttt{0},表示编号为 i 的节点颜色为白色,否则为黑色。
第四行一个正整数 q,表示操作次数。
接下来 q 行每行一个正整数 a_i(1≤ a_i≤ n),表示第 i 次操作选择的节点编号。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 6 3 1 1 3 4 100101 3 1 3 2 | 010000 |
第一次操作后,节点颜色为:\texttt{011010}
第二次操作后,节点颜色为:\texttt{000000}
第三次操作后,节点颜色为:\texttt{010000}
数据范围
| 子任务编号 | 得分 | n | q | 特殊条件 |
| :--: | :--: | :--: | :--: | :--: |
| 1 | 20 | ≤ 10^5 | ≤ 10^5 |对于所有 i≥ 2,节点 i 的父亲节点编号为 i-1
| 2 | 40 | ≤ 1000 | ≤ 1000 | |
| 3 | 40 | ≤ 10^5 | ≤ 10^5 | |
对于全部数据,保证有 n,q≤ 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
有一棵 n 个结点的二叉树(根为 1),每个结点是黑色(1)或白色(0)。进行 q 次操作,每次选一个结点 a,把以 a 为根的子树内所有结点颜色反转。求 q 次操作后每个结点的颜色。
💡人话翻译:不要真的去翻转子树(每次 O(子树大小),q 次会超时)。
关键观察:一个结点被翻转的奇偶性,等于"它自己和它所有祖先被选中的次数之和"的奇偶性。因为"选中 a 会翻转 a 的整棵子树",等价于"只要 v 在 a 的子树里,v 就翻转一次"。
于是从根往下一遍累加就得到每个结点的翻转奇偶。
🔍 关键词提取
子树操作翻转奇偶祖先累加O(n+q)
已知条件
项目说明
输入n;n−1 个父结点;01 串;q;q 个被选结点
输出一行长度 n 的 01 串
数据范围n, q ≤ 10⁵
操作翻转以 a 为根的子树内所有颜色
便利条件父结点编号一定小于子结点编号
需要解决的问题
为什么不能直接模拟?每次翻转要遍历整棵子树,最坏 O(nq) = 10¹⁰,必然超时
怎么转化成计数?记 cnt[a] 为结点 a 被选中的次数。结点 v 的翻转次数 = Σ cnt[u](u 遍历 v 及其所有祖先)
怎么快速累加?flip[v] = flip[parent(v)] + cnt[v];由于父结点编号更小,按编号 1→n 顺序递推即可
🧠 转化
每个结点只关心"被翻了几次"
奇偶性决定最终颜色
选中 a → a 的子树全部翻转
等价于"每个后代都 +1"
📐 累加公式
flip[v] = 翻转 v 的次数
flip[v] = Σ cnt[u](u 是 v 的祖先或自己)
递推:flip[v] = flip[父] + cnt[v]
按编号递增即可
✅ 输出
最终颜色 = 初始颜色 XOR (flip[v] % 2)
按编号顺序输出
0 表示白、1 表示黑
无需真的修改数组
⚠️ 易错点
真的模拟子树翻转(超时)
累加时用父结点的 cnt 而非 flip
忘记加上自己的 cnt
XOR 与 OR 混淆
先理清树的结构(结点 2~6 的父结点依次是 3、1、1、3、4)。
结点父结点
23
31
41
53
64
树形:1 → {3, 4};3 → {2, 5};4 → {6}
初始颜色(1 起):1=1、2=0、3=0、4=1、5=0、6=1。
1
统计操作次数 cnt
操作序列:1、3、2
cnt[1] = 1(被选 1 次)
cnt[3] = 1
cnt[2] = 1
其他 cnt = 0
cnt = {1:1, 2:1, 3:1}
2
按编号从 1 到 6 递推 flip
flip[1] = cnt[1] = 1
flip[2] = flip[3] + cnt[2];先算 flip[3]
flip[3] = flip[1] + cnt[3] = 1 + 1 = 2
所以 flip[2] = 2 + 1 = 3
flip[4] = flip[1] + cnt[4] = 1 + 0 = 1
flip[5] = flip[3] + cnt[5] = 2 + 0 = 2
flip[6] = flip[4] + cnt[6] = 1 + 0 = 1
flip = {1, 3, 2, 1, 2, 1}
3
按奇偶求最终颜色
结点 1:1 XOR (1%2=1) = 0
结点 2:0 XOR (3%2=1) = 1
结点 3:0 XOR (2%2=0) = 0
结点 4:1 XOR (1%2=1) = 0
结点 5:0 XOR (2%2=0) = 0
结点 6:1 XOR (1%2=1) = 0
✅ 输出 "010000"
📊 汇总表
结点初始色cntflipflip 奇偶最终色
1111奇0
2013奇1
3012偶0
4101奇0
5002偶0
6101奇0
输出 "010000" ✓
🔑注意 flip[2] = 3:结点 2 被翻转了 3 次——因为它的祖先里有结点 1(被选 1 次)、结点 3(被选 1 次),再加上自己被选 1 次,共 3 次。
注意"祖先"包含自己(自己也是自己子树的成员),所以递推式是 flip[父] + cnt[自己]。
🧮 验证一次"真的翻转"
为了确认结论正确,我们按题目描述实际模拟一次。
步骤操作操作后颜色串
初始—100101
第 1 次翻转以 1 为根的子树(整棵树)011010
第 2 次翻转以 3 为根的子树(结点 3、2、5)000000
第 3 次翻转以 2 为根的子树(只有结点 2)010000
实际模拟结果 "010000" ✓ 与算法结论一致
⚠️这个验证很有价值:它说明"祖先计数"的方法与"真的翻转"完全等价。
但要注意:实际模拟每次都要遍历整棵子树,复杂度是 O(nq);而计数法只需 O(n + q)——这正是"观察出可累加的不变量"带来的巨大优化。
🟢 祖先计数 + 奇偶(推荐) 推荐
统计每个结点被选次数,从根往下累加得到翻转次数,取奇偶
时间 O(n + q)
n = q = 10⁵ 时约 2 × 10⁵
代码 20 行
空间 O(n)
💡核心两行:cnt[a]++(读操作时统计);flip[v] = flip[par[v]] + cnt[v](按编号递增递推)。利用了"父结点编号更小"这个条件,所以完全不需要建图、不需要 DFS。
🟠 真的翻转整棵子树
每次操作用 DFS 遍历子树并翻转颜色
每次 O(子树大小),最坏 O(n)
q 次合计 O(nq) = 10¹⁰
必然超时
只能过 n,q ≤ 1000 的测试点
⚠️注意数据分档:40% 的测试点 n, q ≤ 1000(可以暴力),但想满分必须 O(n + q)。看到"区间/子树整体操作"就要想到"能不能转化成差分或计数"。
📈 性能对比
方案复杂度可行性
祖先计数O(n + q)✅ 稳过
暴力翻转O(nq)❌ 超时
第一行输入 n,第二行输入父结点,第三行输入颜色串,第四行输入操作数与操作。
输入数据6
3 1 1 3 4
100101
3 1 3 2
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int par[100005], cnt[100005], flip[100005];
char s[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &par[i]); // 题目保证 par[i] < i
scanf("%s", s + 1); // 1-based 颜色串
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int a;
scanf("%d", &a);
cnt[a]++; // 只统计次数,不做翻转
}
flip[1] = cnt[1];
for (int v = 2; v <= n; v++) {
flip[v] = flip[par[v]] + cnt[v]; // 祖先累加
}
for (int v = 1; v <= n; v++) {
int init = s[v] - '0';
int fin = init ^ (flip[v] & 1); // 奇数次翻转才变色
putchar('0' + fin);
}
putchar('\n');
return 0;
}
🔑为什么"只统计次数"就够了?关键在于两次翻转等于没翻转——颜色只有黑/白两种,所以只有"翻转次数的奇偶性"影响结果。
而"v 被翻了几次"正好等于"v 的所有祖先(含自己)被选中的次数之和"——因为每次选中一个祖先,就会把 v 所在的整棵子树都翻一遍。把"整体操作"转化成"逐点计数",这就是本题的核心降维。
📖 关键几行怎么看
代码作用为什么这样写
cnt[a]++统计选次不真的翻转子树
flip[1] = cnt[1]根的翻转次数根的祖先只有自己
flip[v] = flip[par[v]] + cnt[v]递推父结点编号更小,所以按顺序递推即可
init ^ (flip[v] & 1)最终颜色奇数次翻转才变
⚠️四个坑:① 真去模拟子树翻转(O(nq) 超时);② 递推时写成 cnt[par[v]] + cnt[v](只算了父和己,漏了更远的祖先);③ 忘记"自己也要算"(漏 + cnt[v]);④ 用 % 判断奇偶而不用位运算(都对,但位运算更快)。
写完程序后,用这些数据自查一遍:
输入答案考察点
6
3 1 1 3 4
100101
3
1 3 2010000题面样例
3
1 1
000
1
1111翻转以根为根的整棵树,三个结点全变色
3
1 1
000
2
1 1000同一结点选两次,等于没翻
2
1
00
1
111翻转整棵树(根为 1,子树含结点 2)
2
1
01
1
200只翻结点 2 的子树:结点 2 由 1 变 0
✅自查清单:① 只统计次数吗?② 累加用了父的 flip 吗?③ 加了自身 cnt 吗?
🚨 易错点清单
⚠️真模拟翻转:每次 O(子树大小),q 次可能达 10¹⁰。
⚠️累加漏祖先:必须用 flip[par] 而不是 cnt[par]。
⚠️漏掉自己:递推式里要有 + cnt[v]。
时间复杂度
O(n + q)
空间复杂度
O(n)
n, q 最大
10⁵
运算量
约 2 × 10⁵
时间怎么算的?
读操作统计 cnt:O(q)
一次线性递推求 flip:O(n)
输出:O(n)
空间都用在哪?
需要 par、cnt、flip 三个长度 n+1 的数组。
✅ 约 20 万次操作,瞬间完成。相比暴力翻转的 10¹⁰,快了五个数量级。
// 核心观察
// 子树整体操作 <=> 每个后代被操作一次
// 所以只需统计"每个点被选中的次数",再从根往下累加
// 一般树(父结点编号不一定小于子结点)的做法
// 思路一样,只是累加要用拓扑序(BFS/DFS):
vector<int> order; // BFS 顺序
for (int u : order) // 按拓扑序从根往下
for (int v : children[u])
flip[v] = flip[u] + cnt[v];
// 类似"区间整体操作"的差分技巧
// 一维数组区间加 -> 差分数组,最后做前缀和
// 树上的子树操作 -> 本题这种"祖先累加"
// 二者本质相同:把"范围操作"转成"端点标记 + 一次扫描"
// 常见变体
// - 子树加、子树赋值(配合欧拉序转成区间)
// - 路径操作(配合树上差分)
// - 多次整体反转(本题)
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
子树操作转计数祖先累加所有"整棵子树统一操作"的题
翻转只看奇偶两次抵消只有两种状态的反复操作
差分思想端点标记 + 一次扫描区间/子树批量操作
🌟思考题:如果题目改成"每次把从某结点到根的路径上的颜色全部反转",还能用类似的技巧吗?(提示:可以——把"被路径覆盖的次数"累加,用树上差分:每次操作只需在 cnt[a]++,最后自底向上累加到根即可。注意方向变了:子树操作是"自顶向下累加",路径操作是"自底向上累加"。)
#include <bits/stdc++.h>
using namespace std;
int par[100005], cnt[100005], flip[100005];
char s[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &par[i]); // 题目保证 par[i] < i
scanf("%s", s + 1); // 1-based 颜色串
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int a;
scanf("%d", &a);
cnt[a]++; // 只统计次数,不做翻转
}
flip[1] = cnt[1];
for (int v = 2; v <= n; v++) {
flip[v] = flip[par[v]] + cnt[v]; // 祖先累加
}
for (int v = 1; v <= n; v++) {
int init = s[v] - '0';
int fin = init ^ (flip[v] & 1); // 奇数次翻转才变色
putchar('0' + fin);
}
putchar('\n');
return 0;
}// 核心观察
// 子树整体操作 <=> 每个后代被操作一次
// 所以只需统计"每个点被选中的次数",再从根往下累加
// 一般树(父结点编号不一定小于子结点)的做法
// 思路一样,只是累加要用拓扑序(BFS/DFS):
vector<int> order; // BFS 顺序
for (int u : order) // 按拓扑序从根往下
for (int v : children[u])
flip[v] = flip[u] + cnt[v];
// 类似"区间整体操作"的差分技巧
// 一维数组区间加 -> 差分数组,最后做前缀和
// 树上的子树操作 -> 本题这种"祖先累加"
// 二者本质相同:把"范围操作"转成"端点标记 + 一次扫描"
// 常见变体
// - 子树加、子树赋值(配合欧拉序转成区间)
// - 路径操作(配合树上差分)
// - 多次整体反转(本题)给定一棵有 10^9 个结点的有根树,这些结点依次以 1, 2, …, 10^9 编号,根结点的编号为 1。对于编号为 k(2 ≤q k ≤q 10^9)的结点,其父结点的编号为 k 的因数中除 k 以外最大的因数。
现在有 q 组询问,第 i(1 ≤q i ≤q q)组询问给定 x_i, y_i,请你求出编号分别为 x_i, y_i 的两个结点在这棵树上的距离。两个结点之间的距离是连接这两个结点的简单路径所包含的边数。
第一行,一个正整数 q,表示询问组数。
接下来 q 行,每行两个正整数 x_i, y_i,表示询问结点的编号。
输出共 q 行,每行一个整数,表示结点 x_i, y_i 之间的距离。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 1 3 2 5 4 8 | 1 2 1 |
| 2 | 1 120 650 | 9 |
对于 60% 的测试点,保证 1 ≤q x_i, y_i ≤q 1000。
对于所有测试点,保证 1 ≤q q ≤q 1000,1 ≤q x_i, y_i ≤q 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
有一棵以 1 为根、编号 1 ~ 10⁹ 的树。编号 k(k ≥ 2)的结点,父结点是 k 的因数中除 k 以外最大的那个。给定 q 组询问 (xᵢ, yᵢ),求两结点在树上的距离(边数)。
💡人话翻译:两个关键观察——
① k 的最大真因数 = k ÷ k 的最小质因子。所以"往上走一步"就是除掉一个最小的质因子。
② 因此深度 = k 的质因子总个数(含重数),不超过 30 层(因为 2³⁰ > 10⁹)。
于是把两条祖先链都列出来找 LCA,距离 = 深度和 − 2 × LCA 深度。
🔍 关键词提取
最大真因数最小质因子质因数分解LCA祖先链
已知条件
项目说明
输入第一行 q;随后 q 行每行 xᵢ、yᵢ
输出每组一个整数(距离)
数据范围1 ≤ q ≤ 1000
编号范围1 ≤ xᵢ, yᵢ ≤ 10⁹
父结点规则k 的除自身外最大因数
需要解决的问题
最大真因数怎么算?设 k = p × m(p 是 最小质因子),则 m = k/p 就是最大的真因数——因为要让因数尽量大,就要让"除掉的因子"尽量小
树有多深?每走一步就少一个质因子,而 k ≤ 10⁹ < 2³⁰,所以深度 ≤ 30
怎么求距离?把 x 和 y 的祖先链全部列出来(各 ≤ 31 个),从 y 往上找第一个出现在 x 祖先链里的结点,那就是 LCA
🔑 核心转化
k 的最大真因数 = k / spf(k)
spf 表示"最小质因子"
所以父结点 = k 除一个最小质因子
问题变成质因数分解
📏 深度
深度 = Ω(k)(质因子总个数含重数)
k ≤ 10⁹ 所以深度 ≤ 30
祖先链很短
📐 距离
距离 = dep(x) + dep(y) − 2 × dep(LCA)
祖先链列出来找 LCA
各链长度 ≤ 31
O(31) 判断
⚠️ 易错点
把"最大真因数"当成 k/最大质因子
以为深度是"不同质因子个数"
用递归或按编号建树(10⁹ 个结点不可能)
漏掉 x 或 y 为 1 的情形
以 120 = 2³ × 3 × 5 为例,我们一步步往上走(每次除以最小质因子)。
当前结点分解最小质因子父结点
1202³ × 3 × 52120 / 2 = 60
602² × 3 × 5260 / 2 = 30
302 × 3 × 5230 / 2 = 15
153 × 5315 / 3 = 5
5555 / 5 = 1
1(根)———
往上走:120 → 60 → 30 → 15 → 5 → 1,共 5 步(深度 5)
🔑注意链的形状:从根往下看是 1 → 5 → 15 → 30 → 60 → 120,也就是先乘大的质因子(5),再乘小的(3、2、2、2)——正好和"往上除最小质因子"相反。
另外验证一下 深度 = Ω(120) = 3 + 1 + 1 = 5 ✓,即"质因子总个数(含重数)"。
🧮 样例 1:三组询问
q = 3,询问 (1,3)、(2,5)、(4,8)。
1
(1, 3)
x = 1:链 = [1],深度 0
y = 3:3 是质数 → 父结点 = 3/3 = 1
链 = [3, 1],深度 1
x 和 y 的共同祖先:1(深度 0)
距离 = 0 + 1 − 2×0 = 1
✅ 输出 1
2
(2, 5)
x = 2:链 = [2, 1],深度 1
y = 5:链 = [5, 1],深度 1
共同祖先只有 1,深度 0
距离 = 1 + 1 − 0 = 2
✅ 输出 2
3
(4, 8)
x = 4 = 2²:链 = [4, 2, 1],深度 2
y = 8 = 2³:链 = [8, 4, 2, 1],深度 3
从 y 往上找:8 不在 x 链中;4 在 x 链中 → LCA = 4
LCA 深度 = 2
距离 = 2 + 3 − 2×2 = 1
✅ 输出 1
📊 汇总
询问x 的链y 的链LCA距离
1 3[1][3, 1]11
2 5[2, 1][5, 1]12
4 8[4, 2, 1][8, 4, 2, 1]41
输出 1、2、1 ✓
🧮 样例 2:(120, 650),答案 9
这组数据考验"LCA 不一定是 gcd"这个认识。
1
x = 120 的祖先链
120 → 60 → 30 → 15 → 5 → 1
链(从 x 往上)= [120, 60, 30, 15, 5, 1],深度 5
深度 5
2
y = 650 的祖先链
650 = 2 × 5² × 13,最小质因子是 2
650 → 325(除以 2)
325 = 5² × 13,最小质因子 5
325 → 65 → 13(各除以 5)
13 是质数 → 13 → 1
链 = [650, 325, 65, 13, 1],深度 4
深度 4
3
找 LCA
x 的祖先集合 = {120, 60, 30, 15, 5, 1}
y 的祖先集合 = {650, 325, 65, 13, 1}
交集只有 {1} → LCA = 1,深度 0
距离 = 5 + 4 − 0 = 9
✅ 输出 9
答案 9 ✓
⚠️这一组特别值得注意:gcd(120, 650) = 10,但 LCA 并不是 10——因为 10 根本不在任何一条祖先链上!
原因是"往上走"必须每次都除以最小质因子,而 120 和 650 的小质因子剥离顺序不同。所以本题的 LCA 不能简单用 gcd 来算。
🟢 逐次除以最小质因子 + 链上求 LCA(推荐) 推荐
对每次询问分别构造两条祖先链(长度 ≤ 31),找最深公共结点
每组询问 O(√x + Ω(x))
q = 1000 时约 3 × 10⁷
代码 40 行
空间 O(1)
💡三个步骤:① 求 spf(k)(试除到 √k);② 不断 k /= spf(k) 得到整条链;③ 两链求最深公共结点,用 dep(x) + dep(y) − 2·dep(LCA) 得距离。
🟠 按编号真的建一棵 10⁹ 结点的树
预处理父结点数组并做倍增 LCA
需要 10⁹ 大小的数组
内存 完全不可行
时间也不可能
忽略了"链很短"这个关键事实
⚠️量级对比:10⁹ 个结点 vs 每条链 ≤ 31 个结点——差了 3000 万倍。所以本题根本不需要建树,只要"按需构造两条链"即可。
📈 性能对比
方案空间可行性
祖先链O(1)✅ 可过
真建 10⁹ 结点树约 8 GB❌ 不可行
第一行输入 q,随后 q 行输入 x 和 y,程序会构造祖先链并求距离。
输入数据3
1 3
2 5
4 8
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
// 求 k 的最小质因子(k >= 2)
int spf(int k) {
for (int i = 2; (long long)i * i <= k; i++)
if (k % i == 0) return i;
return k; // k 本身是质数
}
// 求 x 到根的整条祖先链(不含根之后),返回 {链结点}
vector<int> chainOf(int x) {
vector<int> c;
c.push_back(x);
while (x > 1) {
x /= spf(x); // 往上走一步:除以最小质因子
c.push_back(x);
}
return c;
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
vector<int> cx = chainOf(x);
vector<int> cy = chainOf(y);
int depX = (int)cx.size() - 1;
int depY = (int)cy.size() - 1;
// 把 x 的祖先放进集合(记录深度)
unordered_map<int, int> depOfX;
for (int i = 0; i < (int)cx.size(); i++)
depOfX[cx[i]] = depX - i;
// 从 y 往上找第一个属于 x 祖先的结点 —— 即 LCA
int depLca = 0;
for (int j = 0; j < (int)cy.size(); j++) {
auto it = depOfX.find(cy[j]);
if (it != depOfX.end()) { depLca = it->second; break; }
}
printf("%d\n", depX + depY - 2 * depLca);
}
return 0;
}
🔑为什么"最大真因数 = k / 最小质因子"?设 k = d × m(d 是某个真因数)。要让因数 m 最大,就要让另一个因子 d 最小。而 d 最小只能取 k 的最小质因子(若取合数,它还能再分解出更小的质因子,对应更大的 m)。所以每往上走一步 = 除掉一个最小质因子,这使得"深度 = 质因子总个数"这个结论非常直观。
📖 关键几行怎么看
代码作用为什么这样写
spf(k)最小质因子试除到 √k 即可,第一个整除的就是最小质因子
x /= spf(x)往上走一步父结点 = 除以最小质因子
while (x > 1)链长度深度 = Ω(x) ≤ 30
depX + depY - 2 * depLca距离公式树上距离的标准公式
⚠️四个坑:① 把"最大真因数"错当成 k / 最大质因子;② 以为深度是"不同质因子个数"(应是含重数的个数);③ 试图真的建一棵 10⁹ 结点的树(会爆内存);④ 忘记处理 x = 1 的情形(此时链只有 [1],深度 0)。
写完程序后,用这些数据自查一遍:
输入答案考察点
3
1 3 / 2 5 / 4 81
2
1题面样例 1
1
120 6509题面样例 2(LCA 不是 gcd)
1
1 10同一个结点,距离 0
1
2 32两个不同质数,只能经根
1
4 644 的链 [4,2,1]、6 的链 [6,3,1],LCA = 1 → 2 + 2 = 4
1
8 1618 的链 [8,4,2,1],16 的链 [16,8,4,2,1] → LCA = 8
✅自查清单:① 除以最小质因子吗?② 深度含重数吗?③ 用链求 LCA 吗?
🚨 易错点清单
⚠️父结点算错:最大真因数 = k ÷ 最小质因子,不是除以最大质因子。
⚠️深度定义错:深度 = 质因子总个数(含重数),如 12 = 2²×3 的深度是 3。
⚠️试图建整棵树:10⁹ 个结点不可能,应按需构造"长度 ≤ 31"的祖先链。
单组询问
O(√x + Ω(x))
空间复杂度
O(Ω(x)) ≤ 31
q 最大
1000
总运算量
约 3 × 10⁷
时间怎么算的?
求一次 spf:试除到 √k ≤ 31623
整条链需要求 Ω(k) ≤ 30 次 spf
最坏 O(30 × 31623) ≈ 10⁶,但实际平均远小于此(大多数数很快就能找到小质因子)
q = 1000 时总计约 3 × 10⁷
空间都用在哪?
每条链最多 31 个整数,加上一个哈希表。
✅ 约 3000 万次操作,可通过。若想更快,可以预先筛出 31623 以内的质数,用质数表去试除。
// 核心结论
// 1. k 的最大真因数 = k / spf(k) (spf = smallest prime factor)
// 2. 深度 = Ω(k)(质因子个数,含重数)≤ 30(因 2^30 > 10^9)
// 3. 距离 = dep(x) + dep(y) - 2 * dep(LCA)
// 求最小质因子的加速版(预筛质数表)
int primes[MAXP], pc;
// 先用埃氏筛打出 sqrt(10^9) = 31623 以内的质数
int spfFast(int k) {
for (int i = 0; i < pc && (long long)primes[i]*primes[i] <= k; i++)
if (k % primes[i] == 0) return primes[i];
return k;
}
// 树上距离公式的通用形式
// dist(u, v) = dep(u) + dep(v) - 2 * dep(lca(u, v))
// 本题的树很浅(≤ 30 层),所以直接暴力枚举链求 LCA 就够
// "编号即结点"的隐式树
// 类似问题:以 n/最小质因子 为父结点的树、约数树、整除格等
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
最大真因数= k / 最小质因子所有"因数关系建树"的题
隐式树按需构造链而非真建树编号范围极大但深度很小的树
树上距离dep 和 − 2×dep(LCA)所有求树上两点距离的问题
🌟思考题:如果题目改成"求 x 的第 k 级祖先"(往上走 k 步),该怎么做?(提示:直接走 k 步就行——每次除以最小质因子,走 k 步最多 30 次运算。本题的树"又宽又浅"(10⁹ 个结点但只有 30 层),这种结构下很多在图上看很麻烦的问题都会变得简单。)
#include <bits/stdc++.h>
using namespace std;
// 求 k 的最小质因子(k >= 2)
int spf(int k) {
for (int i = 2; (long long)i * i <= k; i++)
if (k % i == 0) return i;
return k; // k 本身是质数
}
// 求 x 到根的整条祖先链(不含根之后),返回 {链结点}
vector<int> chainOf(int x) {
vector<int> c;
c.push_back(x);
while (x > 1) {
x /= spf(x); // 往上走一步:除以最小质因子
c.push_back(x);
}
return c;
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
vector<int> cx = chainOf(x);
vector<int> cy = chainOf(y);
int depX = (int)cx.size() - 1;
int depY = (int)cy.size() - 1;
// 把 x 的祖先放进集合(记录深度)
unordered_map<int, int> depOfX;
for (int i = 0; i < (int)cx.size(); i++)
depOfX[cx[i]] = depX - i;
// 从 y 往上找第一个属于 x 祖先的结点 —— 即 LCA
int depLca = 0;
for (int j = 0; j < (int)cy.size(); j++) {
auto it = depOfX.find(cy[j]);
if (it != depOfX.end()) { depLca = it->second; break; }
}
printf("%d\n", depX + depY - 2 * depLca);
}
return 0;
}// 核心结论
// 1. k 的最大真因数 = k / spf(k) (spf = smallest prime factor)
// 2. 深度 = Ω(k)(质因子个数,含重数)≤ 30(因 2^30 > 10^9)
// 3. 距离 = dep(x) + dep(y) - 2 * dep(LCA)
// 求最小质因子的加速版(预筛质数表)
int primes[MAXP], pc;
// 先用埃氏筛打出 sqrt(10^9) = 31623 以内的质数
int spfFast(int k) {
for (int i = 0; i < pc && (long long)primes[i]*primes[i] <= k; i++)
if (k % primes[i] == 0) return primes[i];
return k;
}
// 树上距离公式的通用形式
// dist(u, v) = dep(u) + dep(v) - 2 * dep(lca(u, v))
// 本题的树很浅(≤ 30 层),所以直接暴力枚举链求 LCA 就够
// "编号即结点"的隐式树
// 类似问题:以 n/最小质因子 为父结点的树、约数树、整除格等②编程打卡 · 点一下就能勾选
- 完成 P11962《树上漫步》,跑通全部样例
- 完成 P14076《货物运输》,跑通全部样例
- 完成 P10722《二叉树》,跑通全部样例
- 完成 P13016《最大因数》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
树的遍历与树形 DP
①本日知识点 · 树的遍历与树形 DP
先想清根、再想子树;树形 DP 的合并顺序决定复杂度。
本组 5 道题全部来自 GESP 真题,按「树的遍历与树形 DP」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
对于结点 i,其左儿子的编号记为 l_i,右儿子编号记为 r_i。特别地,如果左儿子不存在则 l_i = 0,如果右儿子不存在则 r_i = 0。
树中每个结点都对应一棵以其为根的子树。请你求出给定有根树的所有 n 棵子树中,有多少棵子树是满二叉树。
满二叉树是指所有叶子深度均相同,且除叶子外均有两个儿子的二叉树,例如以下三棵二叉树均是满二叉树:
() () ()
/ \ / \
() () () ()
/ \ / \
() ()() ()在上面这棵有 3 个节点的二叉树中,有 3 个子树是满二叉树(包括整个树本身,及所有的单个叶子节点);
又例如,
(1)
/ \
(2) (3)
/ \
(4) (5)在上面这棵有 5 个节点的二叉树中,有 4 个子树是满二叉树(包括节点 3 的子树,以及所有单个叶子节点)。
接下来 n 行,每行两个非负整数 l_i, r_i,表示结点 i 的左儿子编号和右儿子编号,整数之间以空格分隔。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 2 3 4 0 0 0 0 0 | 2 |
| 2 | 3 2 3 0 0 0 0 | 3 |
对于 40% 的测试点,保证 1 ≤ n ≤ 500。
对于所有测试点,保证 1 ≤ n ≤ 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定一棵 n 个结点的有根二叉树(根为 1),结点 i 的左右儿子为 lᵢ、rᵢ(不存在则为 0)。求所有 n 棵子树中各有多少棵是满二叉树。
满二叉树指:所有叶子深度相同,且除叶子外每个结点都有两个儿子。
💡人话翻译:这里的"满二叉树"就是完美二叉树(每层都排满)。
判定方法很自然:从叶子往上两两合并——一个结点是完美二叉树,当且仅当它有两个儿子,且两个儿子的子树都是完美二叉树、且高度相同。
于是只需对每个结点记录"是否完美"和"高度"两个信息,自底向上一遍即可,O(n)。
🔍 关键词提取
完美二叉树两状态树形 DP自底向上避免递归爆栈
已知条件
项目说明
输入n;随后 n 行,每行 lᵢ、rᵢ
输出所有子树中满二叉树的个数
数据范围1 ≤ n ≤ 10⁵
标记儿子不存在时编号为 0
判定叶子深度相同 + 非叶子都有两个儿子
需要解决的问题
为什么"两个条件"可以合并成一条?"所有叶子深度相同"等价于"左右子树高度相同且各自内部也已经满足",所以递归判定即可
要多记什么?每个结点记 ok[u](是否完美)与 h[u](高度)
儿子编号比父亲大吗?不保证,所以不能用"编号从大到小"的顺序,必须按树的拓扑序(后序)处理
🍃 叶子
两个儿子都是 0
ok = 真(单结点是完美二叉树)
h = 1
这是递归基
🌲 内部结点
必须两个儿子都存在
且两个子树都 ok
且高度相同 h[left] == h[right]
则 ok = 真,h = 高度 + 1
❌ 不完美的情况
只有一个儿子
某个子树不完美
两个子树高度不同
满足任一即 ok = 假
⚠️ 易错点
用编号顺序递推(儿子编号不一定更大)
递归导致爆栈
只有一个儿子时误判为完美
忘记计数叶子
结构:1 的左儿子 2、右儿子 3;2 只有左儿子 4;3、4 都是叶子。
结点lr子树形状是否完美高度
400单结点✓1
300单结点✓1
240只有左孩子✗2
123左子树不完美✗3
完美子树共 2 棵(结点 3、4)✓
1
为什么结点 2 不是完美?
它只有左儿子 4,没有右儿子
"除叶子外每个结点都要有两个儿子"——结点 2 不是叶子,却只有一个儿子
所以判定为不完美
✗ 结点 2 不完美
2
为什么结点 1 不是完美?
它的左儿子 2 的子树不完美
而且左右子树高度也不同(左边高 2,右边高 1)
两个条件都不满足
所以不完美
✗ 结点 1 不完美
🔑注意"单个叶子也是满二叉树":题目样例说明明确写了"包括整个树本身,及所有的单个叶子节点"。
所以每棵叶子子树都算 1 棵完美子树——这也是为什么样例 2 的答案恰好等于 n。
🧮 样例 2:n = 3,儿子为 (2,3)、(0,0)、(0,0)
这是最"完美"的情形:1 有两个叶子儿子。
结点lr是否完美高度说明
200✓1叶子
300✓1叶子
123✓2两个孩子都是完美且高度相同 → 完美
完美子树共 3 棵 ✓(整棵树 + 两个叶子)
📊 高度与完美性的对照
左右子树高度关系是否完美
都不存在(叶子)✓ 完美
都完美且高度相同✓ 完美
都完美但高度不同✗ 不完美
有一个不完美✗ 不完美
只有一个儿子✗ 不完美
⚠️关于处理顺序的一个重要提醒:题目给的是 lᵢ、rᵢ,儿子的编号不一定大于 i(比如结点 1 的儿子是 5 和 2)。
所以不能简单地"从 n 倒着算到 1",必须按树的后序拓扑顺序处理(先算出所有儿子再算父亲)。实现时可以先从根做一次迭代 DFS 求出后序,再逆序计算。
🟢 两状态树形 DP(推荐) 推荐
每个结点维护 (是否完美, 高度),自底向上合并
时间 O(n)
n = 10⁵ 时约 10⁵
代码 35 行(迭代版)
空间 O(n)
💡合并规则:ok = ok[left] && ok[right] && h[left] == h[right];h = h[left] + 1。注意左右儿子必须都存在,否则直接判假。
🟠 对每棵子树单独判定
枚举 n 个根,各自 DFS 检查所有叶子深度与儿子数
每棵子树 O(子树大小)
总计最坏 O(n²) = 10¹⁰
必然超时
只能过 n ≤ 500 的测试点
⚠️为什么要复用:同一棵子树会在"自己作为根"和"作为父结点的一部分"时被重复检查很多次。把结果缓存成 ok[u]、h[u],就把 O(n²) 压到了 O(n)。
📈 性能对比
方案复杂度可行性
两状态 DPO(n)✅ 稳过
逐子树判定O(n²)❌ 超时
第一行输入 n,随后 n 行输入每个结点的左右儿子编号。
输入数据3
2 3
0 0
0 0
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int lc[100005], rc[100005];
bool ok[100005];
int hgt[100005];
vector<int> order;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d", &lc[i], &rc[i]);
// 迭代求后序:先左、再右、最后自己
vector<pair<int,int>> st; // (结点, 阶段)
vector<bool> seen(n + 1, false);
st.push_back({1, 0});
seen[1] = true;
while (!st.empty()) {
pair<int,int> &top = st.back();
int u = top.first;
if (top.second == 0) {
top.second = 1;
if (lc[u] && !seen[lc[u]]) { seen[lc[u]] = true; st.push_back({lc[u], 0}); continue; }
}
if (top.second <= 1) {
top.second = 2;
if (rc[u] && !seen[rc[u]]) { seen[rc[u]] = true; st.push_back({rc[u], 0}); continue; }
}
order.push_back(u);
st.pop_back();
}
long long ans = 0;
for (int u : order) { // 后序:儿子一定在父亲前面
if (lc[u] == 0 && rc[u] == 0) { // 叶子
ok[u] = true; hgt[u] = 1;
} else if (lc[u] == 0 || rc[u] == 0) { // 只有一个儿子
ok[u] = false;
hgt[u] = 1 + (lc[u] ? hgt[lc[u]] : hgt[rc[u]]);
} else { // 两个儿子都有
ok[u] = ok[lc[u]] && ok[rc[u]] && (hgt[lc[u]] == hgt[rc[u]]);
hgt[u] = hgt[lc[u]] + 1;
}
if (ok[u]) ans++;
}
printf("%lld\n", ans);
return 0;
}
🔑为什么"高度相同"这个条件就够了?因为我们是递归判定的:左右子树各自都已经是完美二叉树(内部所有叶子深度相同),此时只要两边高度相同,那么整棵树的叶子就都落在同一层——"所有叶子深度相同"这个条件自动满足。
这就是"把两个条件合并成一个递归判定"的关键。
📖 关键几行怎么看
代码作用为什么这样写
迭代后序确定处理顺序儿子编号不一定更大,不能按编号倒推
lc[u]==0 && rc[u]==0叶子单结点是完美二叉树
lc[u]==0 || rc[u]==0单儿子不满足"两个儿子"直接判假
ok[l] && ok[r] && hgt[l]==hgt[r]合并两个子树都完美且等高
hgt[u] = hgt[l] + 1高度父亲比儿子高一层
⚠️四个坑:① 按编号从 n 到 1 递推(儿子编号可能更大,会用到未计算的值);② 递归 DFS(n 可达 10⁵,链状数据会爆栈);③ 只有一个儿子时误判为完美;④ 只比较高度而忘记检查两子树自身是否完美。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
2 3
4 0
0 0
0 02题面样例 1(结点 3、4 是完美子树)
3
2 3
0 0
0 03题面样例 2(整棵树 + 两个叶子)
1
0 01只有一个结点,它自己是完美子树
7
2 3
4 5
6 7
0 0
0 0
0 0
0 07三层完美二叉树,7 棵子树全完美
5
2 3
4 0
0 0
0 0
0 02结点 2 只有左儿子;结点 5 孤立(不连通)
✅自查清单:① 按后序处理吗?② 检查了两个儿子都存在吗?③ 高度和完美性都比了吗?
🚨 易错点清单
⚠️按编号倒推:儿子编号可能大于父亲,必须按后序处理。
⚠️递归爆栈:n = 10⁵ 且可能是链,要用迭代后序。
⚠️漏判"只有一个儿子":这种情况一定不完美。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
运算量
约 10⁵
时间怎么算的?
迭代 DFS 求后序:O(n)
按后序合并:每个结点 O(1)
合计 O(n)
空间都用在哪?
左右儿子数组、ok 与高度数组、后序栈,均为 O(n)。
✅ 约 10 万次操作,瞬间完成。关键是"把子树判定结果缓存下来复用",避免 O(n²)。
// 完美(满)二叉树的判定
// 叶子:完美,高度 1
// 内部:两个儿子都存在 && 两个子树都完美 && 高度相同
// 迭代后序模板(儿子编号任意)
vector<pair<int,int>> st; // (结点, 阶段) 0=未处理 1=已入左 2=已入右
st.push_back({root, 0});
while (!st.empty()) {
auto &t = st.back();
int u = t.first;
if (t.second == 0) { t.second = 1; if (lc[u]) { st.push_back({lc[u],0}); continue; } }
if (t.second <= 1) { t.second = 2; if (rc[u]) { st.push_back({rc[u],0}); continue; } }
order.push_back(u); st.pop_back();
}
// order 即为后序(儿子在父亲之前)
// 对照:如果是"完全二叉树"判定(允许最后一层不满)
// 需要记录 (是否完全, 高度, 是否满) 三个信息
// 本题问"满",所以两个信息就够
// 若题目保证 l_i, r_i 都大于 i,则可直接从 n 倒着算,代码更短
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
后序树形 DP先儿子后父亲所有需要子树信息的树题
两状态缓存把结果存下来复用避免 O(n²) 的重复计算
迭代代替递归手动栈n 大且形状可能是链时
🌟思考题:如果题目改成"统计完全二叉树的子树个数"(最后一层可以不满,但必须从左到右连续),状态要怎么改?(提示:需要三个信息——"是否满"、"是否完全"、"高度",因为"左满右完全"这种组合也构成完全二叉树。判定条件越复杂,需要的状态就越多——这正是树形 DP 设计状态的通用规律。)
#include <bits/stdc++.h>
using namespace std;
int lc[100005], rc[100005];
bool ok[100005];
int hgt[100005];
vector<int> order;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d", &lc[i], &rc[i]);
// 迭代求后序:先左、再右、最后自己
vector<pair<int,int>> st; // (结点, 阶段)
vector<bool> seen(n + 1, false);
st.push_back({1, 0});
seen[1] = true;
while (!st.empty()) {
pair<int,int> &top = st.back();
int u = top.first;
if (top.second == 0) {
top.second = 1;
if (lc[u] && !seen[lc[u]]) { seen[lc[u]] = true; st.push_back({lc[u], 0}); continue; }
}
if (top.second <= 1) {
top.second = 2;
if (rc[u] && !seen[rc[u]]) { seen[rc[u]] = true; st.push_back({rc[u], 0}); continue; }
}
order.push_back(u);
st.pop_back();
}
long long ans = 0;
for (int u : order) { // 后序:儿子一定在父亲前面
if (lc[u] == 0 && rc[u] == 0) { // 叶子
ok[u] = true; hgt[u] = 1;
} else if (lc[u] == 0 || rc[u] == 0) { // 只有一个儿子
ok[u] = false;
hgt[u] = 1 + (lc[u] ? hgt[lc[u]] : hgt[rc[u]]);
} else { // 两个儿子都有
ok[u] = ok[lc[u]] && ok[rc[u]] && (hgt[lc[u]] == hgt[rc[u]]);
hgt[u] = hgt[lc[u]] + 1;
}
if (ok[u]) ans++;
}
printf("%lld\n", ans);
return 0;
}// 完美(满)二叉树的判定
// 叶子:完美,高度 1
// 内部:两个儿子都存在 && 两个子树都完美 && 高度相同
// 迭代后序模板(儿子编号任意)
vector<pair<int,int>> st; // (结点, 阶段) 0=未处理 1=已入左 2=已入右
st.push_back({root, 0});
while (!st.empty()) {
auto &t = st.back();
int u = t.first;
if (t.second == 0) { t.second = 1; if (lc[u]) { st.push_back({lc[u],0}); continue; } }
if (t.second <= 1) { t.second = 2; if (rc[u]) { st.push_back({rc[u],0}); continue; } }
order.push_back(u); st.pop_back();
}
// order 即为后序(儿子在父亲之前)
// 对照:如果是"完全二叉树"判定(允许最后一层不满)
// 需要记录 (是否完全, 高度, 是否满) 三个信息
// 本题问"满",所以两个信息就够
// 若题目保证 l_i, r_i 都大于 i,则可直接从 n 倒着算,代码更短老师想将这棵树作为奖品分给两位同学。具体而言,老师会选择一条边并从树上删去它,从而将这棵树分为两个连通块。两位同学分别可以得到其中一个连通块。
如果有同学拿到的连通块结点数明显小于另一位同学,那么这位同学会不太高兴。为了避免这种情况出现,老师想知道两个连通块结点数之差的绝对值最小是多少。
接下来 n-1 行,每行两个正整数 u_i,v_i,表示一条连接结点 u_i 和结点 v_i 的边。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 2 2 3 3 4 | 0 |
| 2 | 6 1 2 1 3 1 4 1 5 5 6 | 2 |
对于所有测试点,保证 2≤ n≤ 2× 10^4。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定一棵 n 个结点的树。选择一条边并删去,树分成两个连通块,求两个连通块结点数之差的最小绝对值。
💡人话翻译:删掉一条边后,其中一个连通块就是"被删边下方那棵子树"。
所以只要求出每条边下方子树的大小 s,另一块的大小就是 n − s,差值是 |n − 2s|。
把所有边的 |n − 2s| 取最小即可。
于是问题归结为"求所有子树的大小",一次 DFS/BFS 就能 O(n) 完成。
🔍 关键词提取
子树大小删除一条边绝对值最小自底向上累加
已知条件
项目说明
输入第一行 n;随后 n−1 行每条边的两个端点
输出两个连通块结点数之差的最小绝对值
数据范围2 ≤ n ≤ 2 × 10⁴
操作删去恰好一条边
目标最小化 |size₁ − size₂|
需要解决的问题
删边后两个块分别是什么?以任意结点为根(选 1 号),每条边都连接一个父亲和一个儿子;删掉后,儿子那侧就是以该儿子为根的子树
怎么求子树大小?自底向上累加:sz[u] = 1 + Σ sz[儿子]
怎么取最小差值?遍历所有非根结点 u,计算 |n − 2·sz[u]| 取最小
🧠 关键转化
删边 = 切出一棵子树
两块大小为 s 与 n − s
差值 = |n − 2s|
于是只需枚举所有子树
📏 子树大小
以 1 为根
自底向上 sz[u] = 1 + Σ sz[儿子]
用后序或逆 BFS 序累加
O(n)
✅ 求答案
遍历每个非根结点 u
ans = min(ans, |n − 2·sz[u]|)
n 为偶数时可能取到 0
n 为奇数时最小为 1
⚠️ 易错点
递归 DFS 爆栈(n = 2×10⁴ 时链状也可能爆)
把根也统计进去(没意义)
忘记取绝对值
用 long long 没必要但无害
以 1 为根,链条就是 1 → 2 → 3 → 4。
结点(子树)子树大小 s另一块大小 n−s差值 |n−2s|
2312
3220
4132
最小差值 0 ✓(删边 2−3,得到 {1,2} 与 {3,4})
1
先求子树大小
sz[4] = 1(叶子)
sz[3] = 1 + sz[4] = 2
sz[2] = 1 + sz[3] = 3
sz[1] = 1 + sz[2] = 4(根,不用)
sz = [4, 3, 2, 1]
2
再算差值
对结点 2:|4 − 2×3| = 2
对结点 3:|4 − 2×2| = 0 ← 最小
对结点 4:|4 − 2×1| = 2
所以答案是 0
✅ 0
💡n 为偶数时可以做到完全均分(前提是存在大小为 n/2 的子树)。
样例 1 中 n = 4,结点 3 的子树大小恰好是 2 = n/2,所以能完美平分 ✓。而 n 为奇数时,两块大小必然一奇一偶,差值最小只能是 1。
🧮 样例 2:n = 6,边为 (1,2)、(1,3)、(1,4)、(1,5)、(5,6),答案 2
结构:1 连着 2、3、4、5;5 连着 6。
结点(子树)子树包含子树大小 s差值 |6−2s|
2{2}14
3{3}14
4{4}14
6{6}14
5{5, 6}22
最小差值 2 ✓(删边 1−5,得到 {5,6} 与 {1,2,3,4})
1
长度计算
sz[2] = sz[3] = sz[4] = sz[6] = 1
sz[5] = 1 + sz[6] = 2
sz[1] = 1 + 1 + 1 + 1 + 2 = 6 ✓(等于 n,正确)
根的子树大小必为 n(可作自检)
2
差值
|6 − 2×1| = 4(四片叶子)
|6 − 2×2| = 2(结点 5)
最小 2
✅ 2
💡 一个自检技巧
算完 sz 之后,检查一下 sz[1] 是否等于 n——如果不等,说明建图或遍历有问题(比如漏了结点、或者有环)。
这是一个非常好用的"结果自检"习惯。
⚠️关于"根结点"的说明:根结点自身没有"父边",所以它不产生任何一条"可删除的边"。
因此遍历时要跳过根,只统计 u = 2..n(或所有非根结点)的子树。如果把根也算进去,会得到一个错误候选(差值为 n)。
🟢 一次遍历求子树大小(推荐) 推荐
以 1 为根求所有子树大小,再对所有非根结点取 |n−2s| 最小
时间 O(n)
n = 2 × 10⁴ 时约 2 × 10⁴
代码 35 行(迭代版)
空间 O(n)
💡实现要点:先 BFS/DFS 得到遍历顺序,再逆序累加 sz[父] += sz[子]。用迭代可以完全避免递归爆栈问题。
🟠 枚举每条边后各自统计连通块
删掉一条边,然后 DFS 数一遍两侧结点数
每条边 O(n)
总计 O(n²) = 4 × 10⁸
可能超时
实现也更麻烦
⚠️量级对比:O(n²) = 4 × 10⁸ vs O(n) = 2 × 10⁴——差了 2 万倍。而且"子树大小"这个信息对所有边都是共用的,算一次就够。
📈 性能对比
方案复杂度(n = 2 × 10⁴)可行性
求子树大小约 2 × 10⁴✅ 瞬间
逐边暴力统计约 4 × 10⁸⚠️ 易超时
第一行输入 n,随后 n−1 行输入每条边的两个端点。
输入数据6
1 2
1 3
1 4
1 5
5 6
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
vector<int> g[20005];
int fa[20005], sz[20005], order[20005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
// 迭代 BFS 求顺序与父子关系
bool vis[20005] = {false};
int head = 0, tail = 0;
order[tail++] = 1;
vis[1] = true;
while (head < tail) {
int u = order[head++];
for (int v : g[u]) {
if (!vis[v]) { vis[v] = true; fa[v] = u; order[tail++] = v; }
}
}
for (int i = 1; i <= n; i++) sz[i] = 1;
// 逆序累加:孩子的 sz 先确定,再加给父亲
for (int i = n - 1; i >= 1; i--) {
int u = order[i];
sz[fa[u]] += sz[u];
}
// 枚举每条"父—子边",求 |n − 2s| 的最小值
int ans = INT_MAX;
for (int u = 2; u <= n; u++) {
ans = min(ans, abs(n - 2 * sz[u]));
}
printf("%d\n", ans);
return 0;
}
🔑为什么"逆序累加"是对的?BFS 得到的顺序满足:父亲一定排在儿子前面。所以逆序遍历时,一定会先处理完所有儿子,再处理父亲——
于是 sz[fa[u]] += sz[u] 时,sz[u] 已经是最终值了 ✓。这个技巧等价于"自底向上的后序",但完全避免了递归。
📖 关键几行怎么看
代码作用为什么这样写
BFS 求 order 与 fa确定层次父亲在儿子之前
sz[i] = 1初始化先算上自己
for (i = n−1; i >= 1; i--)逆序保证儿子先加给父亲
sz[fa[u]] += sz[u]累加子树大小汇总
u 从 2 到 n枚举边跳过根(它没有父边)
⚠️四个坑:① 递归 DFS 导致爆栈(链状数据深度可达 2 × 10⁴);② 把根结点也算进答案(差值为 n,会误以为是候选);③ 忘记取绝对值;④ 忘记"逆序"累加(正序会把儿子的不完整值传给父亲)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
1 2 / 2 3 / 3 40题面样例 1(链,恰好平分)
6
1 2 / 1 3 / 1 4 / 1 5 / 5 62题面样例 2
2
1 20两个结点,删唯一一条边恰好平分
3
1 2 / 1 31n 为奇数,最小差值为 1
5
1 2 / 2 3 / 3 4 / 4 515 个结点的链:切出 2 与 3,差 1
✅自查清单:① 用迭代吗?② 逆序累加吗?③ 跳过了根吗?
🚨 易错点清单
⚠️递归爆栈:n = 2 × 10⁴ 的链会让递归深度过深,用 BFS + 逆序。
⚠️把根也统计:根没有"上面的边",必须跳过。
⚠️正序累加:必须先算儿子再算父亲,即逆序遍历。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
2 × 10⁴
运算量
约 2 × 10⁴
时间怎么算的?
BFS 遍历 O(n)
逆序累加 O(n)
枚举边取最小值 O(n)
空间都用在哪?
邻接表、父子关系、子树大小数组,均 O(n)。
✅ 约 2 万次操作,瞬间完成。核心是把"删边"转化为"枚举子树"。
// 求子树大小的通用模板(迭代版)
BFS: order[], fa[] // 父亲先入队
for (i = 1..n) sz[i] = 1;
for (i = n-1; i >= 1; i--) sz[fa[order[i]]] += sz[order[i]];
// 本题答案
int ans = INT_MAX;
for (int u = 2; u <= n; u++) ans = min(ans, abs(n - 2 * sz[u]));
// 由"子树大小"能解决的一类问题
// 1. 删一条边分成两块的平衡性(本题)
// 2. 删一条边使某块大小恰好为 k
// 3. 树的重心(使最大连通块最小的结点)
// 4. 树上背包(子树的容量)
// 树的重心求法(用到同样的 sz)
// 对每个结点 u,删掉它后最大连通块大小 =
// max(n - sz[u], max sz[v] (v 为 u 的儿子))
// 取这个值最小的结点即为重心
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
子树大小自底向上累加所有涉及"子树规模"的树题
逆序累加用 BFS 顺序的逆序避免递归且保证孩子先算
删边问题转化为枚举子树平衡性、切分类问题
🌟思考题:如果题目改成"删去一条边,要求两块的结点数之差不超过某个值 k,问有多少种删法",代码要怎么改?(提示:还是先求所有子树大小,然后统计满足 |n − 2s| ≤ k 的边数即可。同一个 sz 数组能回答很多不同的问题——这也是"预处理一个通用信息"的价值。)
#include <bits/stdc++.h>
using namespace std;
vector<int> g[20005];
int fa[20005], sz[20005], order[20005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
// 迭代 BFS 求顺序与父子关系
bool vis[20005] = {false};
int head = 0, tail = 0;
order[tail++] = 1;
vis[1] = true;
while (head < tail) {
int u = order[head++];
for (int v : g[u]) {
if (!vis[v]) { vis[v] = true; fa[v] = u; order[tail++] = v; }
}
}
for (int i = 1; i <= n; i++) sz[i] = 1;
// 逆序累加:孩子的 sz 先确定,再加给父亲
for (int i = n - 1; i >= 1; i--) {
int u = order[i];
sz[fa[u]] += sz[u];
}
// 枚举每条"父—子边",求 |n − 2s| 的最小值
int ans = INT_MAX;
for (int u = 2; u <= n; u++) {
ans = min(ans, abs(n - 2 * sz[u]));
}
printf("%d\n", ans);
return 0;
}// 求子树大小的通用模板(迭代版) BFS: order[], fa[] // 父亲先入队 for (i = 1..n) sz[i] = 1; for (i = n-1; i >= 1; i--) sz[fa[order[i]]] += sz[order[i]]; // 本题答案 int ans = INT_MAX; for (int u = 2; u <= n; u++) ans = min(ans, abs(n - 2 * sz[u])); // 由"子树大小"能解决的一类问题 // 1. 删一条边分成两块的平衡性(本题) // 2. 删一条边使某块大小恰好为 k // 3. 树的重心(使最大连通块最小的结点) // 4. 树上背包(子树的容量) // 树的重心求法(用到同样的 sz) // 对每个结点 u,删掉它后最大连通块大小 = // max(n - sz[u], max sz[v] (v 为 u 的儿子)) // 取这个值最小的结点即为重心
某节课上,老师安排全班同学进行一次握手游戏,具体规则如下:老师安排了一个顺序,让全班 N 名同学依次进入教室。每位同学进入教室时,需要和 已经在教室内 且 学号小于自己 的同学握手。
现在,小杨想知道,整个班级总共会进行多少次握手。
提示:可以考虑使用归并排序进行降序排序,并在此过程中求解。
保证每位同学会且只会进入教室一次。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 2 1 3 0 | 2 |
| 2 | 6 0 1 2 3 4 5 | 15 |
2 号同学进入教室,此时教室里没有其他同学。
1 号同学进入教室,此时教室里有 2 号同学。1 号同学的学号小于 2 号同学,因此他们之间不需要握手。
3 号同学进入教室,此时教室里有 1,2 号同学。3 号同学的学号比他们都大,因此 3 号同学需要分别和另外两位同学握手。
0 号同学进入教室,此时教室里有 1,2,3 号同学。0 号同学的学号比他们都小,因此 0 号同学不需要与其他同学握手。
样例解释2:
全班所有同学之间都会进行握手,因为每位同学来到教室时,都会发现他的学号是当前教室里最大的,所以他需要和教室里的每位其他同学进行握手。
对于 30% 的测试点,保证 N≤100。
对于所有测试点,保证 2≤ N≤3×10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
N 名同学学号 0 ~ N−1,按给定顺序依次进入教室。每位同学进入时,要和已经在教室内、且学号小于自己的同学握手。求全班一共握手多少次。
💡人话翻译:把"进入顺序"看成一个序列。对任意先进入的 i 和后进入的 j(i 在 j 前面),他们握手 ⟺ i 的学号小于 j 的学号。
所以答案就是序列中"顺序对"的个数(即前面小、后面大的配对),用归并排序(或树状数组)在 O(N log N) 内统计。
🔍 关键词提取
顺序对计数归并排序逆序对变体树状数组
已知条件
项目说明
输入第一行 N;第二行是进入顺序(学号排列)
输出握手总次数
数据范围2 ≤ N ≤ 3 × 10⁵
序列性质是 0 ~ N−1 的一个排列
答案可能很大最大可达 N(N−1)/2 ≈ 4.5 × 10¹⁰
需要解决的问题
为什么是"顺序对"而不是"逆序对"?因为条件是"先来的学号更小",即 a_i < a_j(i < j)
怎么和逆序对联系起来?把序列倒过来看,顺序对就变成逆序对;或者直接用 C(N,2) − 逆序对数
为什么不能双重循环?N = 3 × 10⁵ 时两两配对约 4.5 × 10¹⁰,必然超时
🧠 模型转化
按进入顺序排成序列 a
i 在 j 前且 a_i 所以答案是"顺序对"个数
与"逆序对"互为补集
📐 两种做法
做法一:直接统计顺序对
做法二:C(N,2) − 逆序对数
逆序对可用归并/BIT
答案一定相同
⚡ 归并排序
分治:左右两半各自排序
合并时若取左半元素,说明它更小
此时右半剩下的都更大 → 累加顺序对
O(N log N)
⚠️ 易错点
统计成逆序对(方向反了)
用 int 存答案(可达 4.5 × 10¹⁰)
归并写错导致漏计
N = 2 等边界
逐个同学模拟一遍,同时用"顺序对"视角核对。
次序进入者学号教室内已有其中比它学号小的本次握手
12(空)—0
212无(1 < 2 不满足)0
331, 21、2 都小于 32
401, 2, 3无(0 最小)0
总计 2 ✓
1
用"顺序对"核对
序列 a = [2, 1, 3, 0]
所有 i < j 的配对,检查 a_i < a_j:
(2,1) → 2 > 1 ✗
(2,3) → 2 < 3 ✓
(2,0) → 2 > 0 ✗
(1,3) → 1 < 3 ✓
(1,0) → 1 > 0 ✗
(3,0) → 3 > 0 ✗
共 2 个 ✓
✅ 与模拟一致
🔑注意这两组数据的关系:序列 [2,1,3,0] 的逆序对是 4 个((2,1)、(2,0)、(1,0)、(3,0)),顺序对是 2 个,4 + 2 = C(4,2) = 6 ✓。两者互补,所以也可以"统计逆序对再取补"。
🧮 样例 2:进入顺序 0 1 2 3 4 5,答案 15
学号递增入场,每个新来的学号都是教室里最大的,所以要跟所有人握手。
1
逐个统计
第 1 位(0):0 人
第 2 位(1):1 人
第 3 位(2):2 人
第 4 位(3):3 人
第 5 位(4):4 人
第 6 位(5):5 人
合计 0 + 1 + 2 + 3 + 4 + 5 = 15
✅ 15
2
用公式核对
这种情况所有配对都握手
总数 = C(6,2) = 6 × 5 / 2 = 15 ✓
✅ 一致
📊 三种情况对照
序列特点顺序对数量说明
严格递增C(N,2)(最大)人人都和所有人握手
严格递减0(最小)每次来的都是最小的,无人可握
随机排列介于两者之间期望约 C(N,2)/2
⚠️注意这个"互补"关系:递增序列的顺序对是 C(N,2)、逆序对是 0;递减序列正好相反。
所以做题时一定要看清"谁来跟谁握手"的方向——题目说"和学号小于自己的同学握手",那就对应"顺序对"。如果理解成"和学号大于自己的握手",答案就完全反了。
🟢 归并排序统计(推荐) 推荐
分治合并时累计"顺序对"贡献
时间 O(N log N)
N = 3 × 10⁵ 时约 6 × 10⁶
代码 30 行
题目提示里就推荐了它
💡合并时的计数规则:当从左半取出一个元素时,说明它比右半剩余的元素都小,于是累加"右半剩余元素个数"到答案。这与统计逆序对的写法正好相反(那时取右半元素才累加)。
🟠 树状数组
从左到右扫描,用 BIT 查询"已出现且比当前小的个数"
时间 O(N log N)
代码更短(约 25 行)
思路直接
需要值域大小 N
⚠️两种都很好:BIT 的写法是"边扫边查",更容易理解;归并排序不需要额外的树结构。题目提示推荐归并,但 BIT 同样正确。
📈 性能对比
方案复杂度代码量
归并排序O(N log N)约 30 行
树状数组O(N log N)约 25 行
双重循环O(N²) = 4.5 × 10¹⁰❌ 超时
输入进入顺序,程序用暴力法统计顺序对(演示规模内),并展示每位同学的握手次数。
输入进入顺序
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int a[300005], tmp[300005];
long long ans = 0;
void mergeSort(int l, int r) {
if (l >= r) return;
int mid = (l + r) / 2;
mergeSort(l, mid);
mergeSort(mid + 1, r);
int i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (a[i] < a[j]) {
// 取左半元素:它比右半"剩余"的都小,产生顺序对
ans += (long long)(r - j + 1);
tmp[k++] = a[i++];
} else {
tmp[k++] = a[j++];
}
}
while (i <= mid) tmp[k++] = a[i++];
while (j <= r) tmp[k++] = a[j++];
for (int t = l; t <= r; t++) a[t] = tmp[t];
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
mergeSort(0, N - 1);
printf("%lld\n", ans);
return 0;
}
🔑为什么"取左半元素"时要累加 r − j + 1?因为此时右半还没被取走的元素是 a[j..r],它们都比 a[i] 大(因为两半各自有序),所以 a[i] 与这 r − j + 1 个元素都构成"顺序对"(左小右大)✓。
统计逆序对时恰好相反:那时是在"取右半元素"时累加 mid − i + 1。
📖 关键几行怎么看
代码作用为什么这样写
mergeSort(l, mid); mergeSort(mid+1, r);分治两半各自有序后才能线性合并
if (a[i] < a[j]) ans += r - j + 1;核心计数取左半 → 产生顺序对
else tmp[k++] = a[j++];取右半不产生顺序对(右元素不更大)
long long ans类型答案可达 4.5 × 10¹⁰,必须 long long
⚠️四个坑:① 把顺序对统计成逆序对(应在"取左半"时累加);② 用 int 存答案;③ 忘记把临时数组拷回原数组(导致后续层出错);④ 递归深度(N = 3 × 10⁵ 时归并递归深度只有约 19 层,安全)。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
2 1 3 02题面样例 1
6
0 1 2 3 4 515题面样例 2
2
1 00先来学号 1,后来 0:0 不是更小,不握手
2
0 11先来 0,1 进来时学号更大 → 握手 1 次
3
2 1 00严格递减,无人握手
3
0 1 23严格递增,等于 C(3,2) = 3
✅自查清单:① 统计的是顺序对吗?② 用 long long 吗?③ 复杂度 O(N log N) 吗?
🚨 易错点清单
⚠️方向搞反:条件是"已入场且学号更小",对应顺序对,不是逆序对。
⚠️用 int:答案最大约 4.5 × 10¹⁰,需 long long。
⚠️暴力双重循环:N = 3 × 10⁵ 时会超时,需 O(N log N)。
时间复杂度
O(N log N)
空间复杂度
O(N)
N 最大
3 × 10⁵
运算量
约 6 × 10⁶
时间怎么算的?
归并排序共 log N 层
每层合计 O(N) 的合并工作
合计 O(N log N) ≈ 6 × 10⁶
空间都用在哪?
需要与原数组等长的临时数组。
✅ 约 600 万次操作,瞬间完成。相比暴力枚举两两配对的 4.5 × 10¹⁰,快了四个数量级。
// 归并排序统计"顺序对"(左小右大)
if (a[i] < a[j]) { ans += r - j + 1; tmp[k++] = a[i++]; }
else { tmp[k++] = a[j++]; }
// 对照:统计"逆序对"(左大右小)
if (a[i] <= a[j]) { tmp[k++] = a[i++]; }
else { ans += mid - i + 1; tmp[k++] = a[j++]; }
// 两者的关系
// 顺序对数 + 逆序对数 = C(N, 2)
// 所以统计出任意一个,另一个用总数减即可
// 用树状数组统计"已出现且更小"的个数
// for (i = 0..N-1) { ans += query(a[i] - 1); add(a[i], 1); }
// 归并排序还能顺便完成排序,一举两得
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
顺序对左小右大的配对握手、配对、正序关系计数
逆序对左大右小的配对排序最少交换次数、逆序统计
互补关系顺序对 + 逆序对 = C(N,2)两种统计互相验证
🌟思考题:如果题目改成"和学号大于自己的同学握手",答案会变成什么?(提示:就变成逆序对了,而且此时"顺序对 + 逆序对 = C(N,2)",所以新答案是 C(N,2) − 原答案。同一道题,规则方向一改,答案就是互补的——读题时务必逐字看清。)
#include <bits/stdc++.h>
using namespace std;
int a[300005], tmp[300005];
long long ans = 0;
void mergeSort(int l, int r) {
if (l >= r) return;
int mid = (l + r) / 2;
mergeSort(l, mid);
mergeSort(mid + 1, r);
int i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (a[i] < a[j]) {
// 取左半元素:它比右半"剩余"的都小,产生顺序对
ans += (long long)(r - j + 1);
tmp[k++] = a[i++];
} else {
tmp[k++] = a[j++];
}
}
while (i <= mid) tmp[k++] = a[i++];
while (j <= r) tmp[k++] = a[j++];
for (int t = l; t <= r; t++) a[t] = tmp[t];
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
mergeSort(0, N - 1);
printf("%lld\n", ans);
return 0;
}// 归并排序统计"顺序对"(左小右大)
if (a[i] < a[j]) { ans += r - j + 1; tmp[k++] = a[i++]; }
else { tmp[k++] = a[j++]; }
// 对照:统计"逆序对"(左大右小)
if (a[i] <= a[j]) { tmp[k++] = a[i++]; }
else { ans += mid - i + 1; tmp[k++] = a[j++]; }
// 两者的关系
// 顺序对数 + 逆序对数 = C(N, 2)
// 所以统计出任意一个,另一个用总数减即可
// 用树状数组统计"已出现且更小"的个数
// for (i = 0..N-1) { ans += query(a[i] - 1); add(a[i], 1); }
// 归并排序还能顺便完成排序,一举两得初始时 T 中的结点均为白色。你需要将 T 中的若干个结点染为黑色,使得所有叶子到根的路径上至少有一个黑色结点。将结点 i 染为黑色需要代价 c_i,你需要在满足以上条件的情况下,最小化染色代价之和。
叶子是指 T 中没有子结点的结点。
第二行,n-1 个正整数 f_2,f_3,…,f_n,其中 f_i 表示结点 i 的父结点的编号,保证 f_i<i。
第三行,n 个正整数 c_1,c_2,…,c_n,其中 c_i 表示将结点 i 染为黑色所需的代价。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 1 2 3 5 6 2 3 | 2 |
| 2 | 7 1 1 2 2 3 3 64 16 15 4 3 2 1 | 10 |
对于另外 20% 的测试点,保证 f_i=i-1。
对于所有测试点,保证 2≤ n≤ 10^5,1≤ c_i≤ 10^9。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定一棵以 1 为根的有根树,结点初始全白。要把若干结点染黑,使所有叶子到根的路径上至少有一个黑点。结点 i 染黑需代价 cᵢ,求最小总代价。
叶子指没有子结点的结点。
💡人话翻译:树形 DP 的经典模型。关键是为每个结点设计两个状态:
dp[u][0]:假设"u 到根的方向上还没有黑点",把 u 子树覆盖完的最小代价;
dp[u][1]:假设"u 上方已经有黑点",把 u 子树覆盖完的最小代价(此时子树其实已自动覆盖,只需保证递归一致)。
🔍 关键词提取
树形 DP状态设计自底向上避免递归爆栈
已知条件
项目说明
输入第一行 n;第二行 n−1 个 f₂…fₙ;第三行 n 个 cᵢ
输出最小染色代价
数据范围2 ≤ n ≤ 10⁵
树上性质fᵢ < i(父结点编号更小)
代价范围1 ≤ cᵢ ≤ 10⁹
需要解决的问题
为什么需要两个状态?因为"子树里要不要自己解决覆盖问题",取决于上方是否已有黑点
叶子怎么办?叶子 u 若上方无黑点,必须自己染黑 → dp[u][0] = c_u;若上方有黑点 → dp[u][1] = 0
内部结点呢?dp[u][1] = Σ dp[v][1](上方有黑点,孩子也都"被覆盖");dp[u][0] = min(c_u + Σ dp[v][1], Σ dp[v][0])(要么染 u 自己,要么让每个孩子自己解决)
🧠 状态定义
dp[u][0]:上方没有黑点
dp[u][1]:上方已有黑点
区别在于"谁来覆盖叶子"
自底向上计算
🍃 叶子
无子结点
dp[u][0] = c_u(必须自己染)
dp[u][1] = 0(已覆盖)
这是边界
🌲 内部结点
dp[u][1] = Σ dp[v][1]
dp[u][0] = min(c_u + Σ dp[v][1], Σ dp[v][0])
两种决策:染自己 or 让孩子自己解决
取较小值
⚠️ 易错点
只用一个状态(无法区分情形)
递归爆栈(n 达 10⁵)
用 int(代价可达 10¹⁴)
把根结点当成"上方有黑点"
n = 4,f = [1, 2, 3](即 f₂=1、f₃=2、f₄=3),c = [5, 6, 2, 3]。叶子只有结点 4。
1
结点 4(叶子)
dp[4][0] = c₄ = 3(上方没黑点,必须自己染)
dp[4][1] = 0(上方已有黑点,自动覆盖)
dp[4] = (3, 0)
2
结点 3(唯一孩子是 4)
dp[3][1] = dp[4][1] = 0
dp[3][0] = min(c₃ + dp[4][1], dp[4][0])
= min(2 + 0, 3) = min(2, 3) = 2
即"染结点 3 自己"(代价 2)比"让 4 自己染"(代价 3)划算
dp[3] = (2, 0)
3
结点 2
dp[2][1] = dp[3][1] = 0
dp[2][0] = min(6 + 0, dp[3][0]) = min(6, 2) = 2
让结点 3 染黑(2)比染结点 2(6)便宜
dp[2] = (2, 0)
4
结点 1(根,它上方一定没有黑点)
dp[1][1] = dp[2][1] = 0(实际上根用不到这个状态)
dp[1][0] = min(5 + 0, dp[2][0]) = min(5, 2) = 2
答案 = dp[1][0] = 2
✅ 答案 2
最优方案:只把结点 3 染黑(代价 2),叶子 4 到根 1 的路径 4→3→2→1 上经过了 3 ✓
🧮 样例 2:分叉树
n = 7,f = [1, 1, 2, 2, 3, 3] → 1 的孩子是 2、3;2 的孩子是 4、5;3 的孩子是 6、7。叶子是 4、5、6、7。c = [64, 16, 15, 4, 3, 2, 1]。
1
层 1:叶子 4、5、6、7
dp[4] = (4, 0)、dp[5] = (3, 0)
dp[6] = (2, 0)、dp[7] = (1, 0)
四个叶子的状态已定
2
层 2:结点 2 与 3
dp[2][1] = dp[4][1] + dp[5][1] = 0
dp[2][0] = min(c₂ + (dp[4][1]+dp[5][1]), dp[4][0]+dp[5][0])
= min(16 + 0, 4 + 3) = min(16, 7) = 7
dp[3][1] = 0
dp[3][0] = min(15 + 0, 2 + 1) = min(15, 3) = 3
dp[2] = (7, 0),dp[3] = (3, 0)
3
层 3:根结点 1
dp[1][0] = min(c₁ + (dp[2][1]+dp[3][1]), dp[2][0]+dp[3][0])
= min(64 + 0, 7 + 3) = min(64, 10) = 10
答案 = dp[1][0] = 10
✅ 答案 10
📊 各结点状态汇总
结点cdp[·][0]dp[·][1]决策说明
4(叶)440必须自己染
5(叶)330必须自己染
6(叶)220必须自己染
7(叶)110必须自己染
21670让孩子 4、5 自己染(4+3=7 < 16)
31530让孩子 6、7 自己染(2+1=3 < 15)
1(根)6410—让 2、3 子树自己解决(7+3=10 < 64)
最优方案:叶子 4、5、6、7 都染黑,总代价 4+3+2+1 = 10 ✓
🔑这组数据很有启发:根结点染色要 64、结点 2 要 16、结点 3 要 15——都很贵;而四个叶子加起来只要 10。所以最优解是"在叶子处全部染黑"。dp[u][0] 里的 min 正好在这两种策略间取更便宜的那个。
🟢 树形 DP(两状态)(推荐) 推荐
自底向上算 dp[u][0] 与 dp[u][1],答案是 dp[1][0]
时间 O(n)
n = 10⁵ 时约 10⁵ 次
代码 25 行(迭代版)
空间 O(n)
💡两个状态的含义要记清:dp[u][0] 表示"u 上方无黑点"、dp[u][1] 表示"u 上方有黑点"。转移里的 min 恰好对应"在 u 染色"与"让子树自己解决"两种策略的取舍。
🟠 状压 / 枚举染哪些结点
枚举所有染色方案,检查是否覆盖所有叶子路径
复杂度 2ⁿ
40% 测试点 n ≤ 16 时可得部分分
n = 10⁵ 完全不可行
只适合小数据
⚠️注意数据分档:40% 的测试点 n ≤ 16(可以状压拿 40 分),但想满分必须用树形 DP。另外注意:这题不能贪心——"从叶子往上找最便宜的点"这类贪心在多分支树上会被反例击破。
📈 性能对比
方案复杂度可行性
树形 DPO(n)✅ 稳过
状压枚举O(2ⁿ)❌ n 大时不可行
贪心选点O(n)❌ 无正确性保证
第一行输入 n,第二行输入父结点,第三行输入代价,程序会自底向上算 dp。
输入数据7
1 1 2 2 3 3
64 16 15 4 3 2 1
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
long long c[100005];
int par[100005], degCnt[100005];
long long sum0[100005], sum1[100005]; // 孩子 dp 的累加
long long dp0[100005], dp1[100005];
int main() {
int n;
scanf("%d", &n);
par[1] = 0;
for (int i = 2; i <= n; i++) scanf("%d", &par[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &c[i]);
// 因为 f_i < i,孩子编号一定大于父亲
// 所以从 n 递减到 2 处理,能保证"孩子先算完"
for (int i = n; i >= 2; i--) {
if (degCnt[i] == 0) { // 叶子:上方没黑点就必须自己染
dp0[i] = c[i];
dp1[i] = 0;
} else { // 内部结点
dp1[i] = sum1[i];
dp0[i] = min(c[i] + sum1[i], sum0[i]);
}
// 把结果累加给父亲
int p = par[i];
sum0[p] += dp0[i];
sum1[p] += dp1[i];
degCnt[p]++;
}
// 根结点(它上方一定没有黑点,所以取 dp0)
long long ans;
if (degCnt[1] == 0) ans = c[1]; // 特殊情形:n = 1
else ans = min(c[1] + sum1[1], sum0[1]);
printf("%lld\n", ans);
return 0;
}
🔑为什么不用递归?n 可达 10⁵,如果树退化成一条链,递归深度就是 10⁵,会爆栈(默认栈空间通常只够几万层)。
而题目给了关键条件 fᵢ < i——父亲的编号一定小于孩子,所以只要从 n 递减到 2 遍历,就一定能在处理父结点前算完所有孩子。这个"逆序迭代"技巧让代码既简单又不会爆栈。
📖 关键几行怎么看
代码作用为什么这样写
fᵢ < i 的利用逆序遍历的基础孩子编号更大 → 从 n 往下处理
degCnt[i] == 0判断叶子累加过程中统计孩子个数
dp0[i] = min(c[i] + sum1[i], sum0[i])核心转移染自己 vs 让子树自己解决
sum0[p] += dp0[i]向上汇总把孩子的 dp 累加到父亲
ans = min(c[1] + sum1[1], sum0[1])根的答案根上方无黑点,所以用 dp0 的公式
⚠️四个坑:① 用递归导致爆栈(n 达 10⁵);② 只设一个状态(无法区分"上方有无黑点");③ 用 int(n × cᵢ 可达 10⁵ × 10⁹ = 10¹⁴);④ 答案错误地取 dp[1][1](根上方没有黑点,应该取 dp[1][0])。
写完程序后,用这些数据自查一遍:
输入答案考察点
4
1 2 3
5 6 2 32题面样例 1(一条链,染结点 3)
7
1 1 2 2 3 3
64 16 15 4 3 2 110题面样例 2(四个叶子全染)
2
1
5 33一条边:染叶子更便宜
2
1
3 53一条边:染根更便宜
3
1 1
10 1 12根贵,两个叶子各染一次
✅自查清单:① 用迭代而非递归吗?② 两个状态都有吗?③ 答案取根结点的 dp0 吗?
🚨 易错点清单
⚠️递归爆栈:n 达 10⁵ 且可能是链,要用"从 n 递减到 2"的迭代写法。
⚠️单状态 DP:必须区分"上方有无黑点"两种情况,否则转移无法表达。
⚠️答案取错:根上方一定没有黑点,所以答案是 dp[1][0]。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
运算量
约 10⁵
时间怎么算的?
每个结点只处理一次
每次 O(1) 的 min 与加法
合计 O(n)
空间都用在哪?
需要存父结点、代价、以及每个结点的 dp 与孩子累加值,共约 6 个 O(n) 数组。
✅ 约 10 万次运算,瞬间完成。本题的难点是"状态设计",不是复杂度。
// 树形 DP 的通用套路
// 1. 设计状态:让"子树内的问题"能被独立描述
// 本题:dp[u][0]/dp[u][1] 取决于"上方是否有黑点"
// 2. 找边界:叶子结点
// 3. 写转移:枚举"u 的决策",用孩子的 dp 表达
// 4. 定答案:根结点的某个状态
// 避免递归爆栈的两种写法
// 写法 A(本题,利用 f_i < i):
for (int i = n; i >= 2; i--) { 计算 dp[i]; 累加到 par[i]; }
// 写法 B(一般树):先求拓扑序(BFS/DFS 迭代),再逆序处理
vector<int> order; // BFS 顺序
for (auto it = order.rbegin(); it != order.rend(); ++it) { 计算 dp[*it]; }
// 如果真要递归,可以手动开大栈(部分评测环境支持):
// #pragma comment(linker, "/STACK:...")
// 但更稳妥的做法就是上面两种迭代写法
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
树形 DP状态 + 边界 + 转移所有树上选择/覆盖类问题
两状态设计"上方有无"决定子问题路径覆盖、支配集、最小点覆盖
逆序迭代利用 f_i 避免 n = 10⁵ 时递归爆栈
🌟思考题:如果题目改成"每条根到叶的路径上恰好有一个黑点"(恰好而不是至少),DP 要怎么改?(提示:需要第三个状态——记录"这条路径上已经放了几个黑点"(0 个 / 1 个 / ≥2 个)。因为"至少一个"只要两状态就够,而"恰好一个"必须防止放第二个。约束越精确,状态设计就越复杂——这是树形 DP(以及所有 DP)的核心难点。)
#include <bits/stdc++.h>
using namespace std;
long long c[100005];
int par[100005], degCnt[100005];
long long sum0[100005], sum1[100005]; // 孩子 dp 的累加
long long dp0[100005], dp1[100005];
int main() {
int n;
scanf("%d", &n);
par[1] = 0;
for (int i = 2; i <= n; i++) scanf("%d", &par[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &c[i]);
// 因为 f_i < i,孩子编号一定大于父亲
// 所以从 n 递减到 2 处理,能保证"孩子先算完"
for (int i = n; i >= 2; i--) {
if (degCnt[i] == 0) { // 叶子:上方没黑点就必须自己染
dp0[i] = c[i];
dp1[i] = 0;
} else { // 内部结点
dp1[i] = sum1[i];
dp0[i] = min(c[i] + sum1[i], sum0[i]);
}
// 把结果累加给父亲
int p = par[i];
sum0[p] += dp0[i];
sum1[p] += dp1[i];
degCnt[p]++;
}
// 根结点(它上方一定没有黑点,所以取 dp0)
long long ans;
if (degCnt[1] == 0) ans = c[1]; // 特殊情形:n = 1
else ans = min(c[1] + sum1[1], sum0[1]);
printf("%lld\n", ans);
return 0;
}// 树形 DP 的通用套路
// 1. 设计状态:让"子树内的问题"能被独立描述
// 本题:dp[u][0]/dp[u][1] 取决于"上方是否有黑点"
// 2. 找边界:叶子结点
// 3. 写转移:枚举"u 的决策",用孩子的 dp 表达
// 4. 定答案:根结点的某个状态
// 避免递归爆栈的两种写法
// 写法 A(本题,利用 f_i < i):
for (int i = n; i >= 2; i--) { 计算 dp[i]; 累加到 par[i]; }
// 写法 B(一般树):先求拓扑序(BFS/DFS 迭代),再逆序处理
vector<int> order; // BFS 顺序
for (auto it = order.rbegin(); it != order.rend(); ++it) { 计算 dp[*it]; }
// 如果真要递归,可以手动开大栈(部分评测环境支持):
// #pragma comment(linker, "/STACK:...")
// 但更稳妥的做法就是上面两种迭代写法对于结点 i,其左儿子的编号记为 l_i,右儿子编号记为 r_i。特别地,如果左儿子不存在则 l_i=0,如果右儿子不存在则 r_i=0。
树中每个结点都对应一棵以其为根的子树。请你求出给定有根树的所有 n 棵子树中,有多少棵子树是完全二叉树。
接下来 n 行,每行两个正整数 l_i,r_i,表示结点 i 的左儿子编号和右儿子编号。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 4 2 3 4 0 0 0 0 0 | 4 |
| 2 | 4 2 3 0 0 4 0 0 0 | 3 |
对于所有测试点,保证 1≤q n≤q 10^5。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
给定一棵包含 n 个结点的有根二叉树,结点依次以 1,2,…,n 编号,根结点编号为 1。
对于结点 i,其左儿子的编号记为 lᵢ,右儿子编号记为 rᵢ。特别地,如果左儿子不存在则 lᵢ = 0,如果右儿子不存在则 rᵢ = 0。
树中每个结点都对应一棵以其为根的子树。请你求出给定有根树的所有 n 棵子树中,有多少棵子树是完全二叉树。
💡
人话翻译:题目把每个结点的左右孩子都告诉你了。你需要盯着这棵树看:
以每个结点为"根"往下看,能组成一棵小树(子树),一共 n 个小树。
问这些小树里,有几棵长得"规规矩矩"(完全二叉树)。注意:叶子结点自己也算一棵子树。
🔍 关键词提取
有根二叉树
完全二叉树
子树计数
后序遍历
树形 DP
已知条件
项目说明
树的规模n 个结点,编号 1 ∼ n
根结点固定为编号 1
输入格式第一行 n;接下来 n 行,第 i 行是 lᵢ rᵢ
孩子约定不存在时记 0;不保证孩子编号大于父结点
输出所有子树中「完全二叉树」的棵数
数据范围40% 测试点 n ≤ 500;全部测试点 n ≤ 10⁵
需要解决的问题
完全二叉树的判定标准是什么?→ 除最后一层外每层都满,且最后一层的结点全部靠左排列
判断一棵子树是否完全,需要哪些信息?→ 高度、是否满、是否完全,三个量缺一不可
怎么避免对每棵子树重复扫描?→ 后序遍历,自底向上一次算完,把子树结论直接交给父结点
⚠️
注意"计数对象":题目数的是所有 n 棵子树(每个结点各贡献一棵),不是"整棵树是不是完全二叉树"这一个是非判断。
所以答案最小也有叶子结点那么多。
📥 输入建模
1️⃣根固定为 1 号结点
📦数组 lc[]、rc[] 存左右孩子
0️⃣0 表示孩子不存在
🚫不保证孩子编号更大
📏 判定三要素
📐高度 h:最长链的长度
🟩满 full:结点数 = 2ʰ−1
✅完全 cmpl:本题要求的性质
🔗满 ⇒ 完全,反之不成立
🔁 递推设计
⬇️后序遍历:先算左右孩子
📤每个结点返回三元组
⚖️比较左右高度 hl、hr
⏱️每个结点 O(1) 合并
🕳️ 边界与陷阱
🌱空子树:h=0、满=真、完全=真
➡️只有右孩子 ⇒ 必定不完全
🪜链状树深度可达 10⁵
💥递归可能爆栈,需迭代
两个样例都是 n=4,输入只差一行,但答案分别是 4 和 3。区别就在结点 2 和结点 3 谁有孩子。
样例 1:4 棵子树全为完全二叉树 → 答案 4
1
2
3
4
h=3
h=2
h=1
h=1
左子树高 2、右子树高 1 → 矮的一边在右边 ✓
样例 2:只有 3 棵完全二叉树 → 答案 3
1
2
3
4
h=3
h=1
h=2
h=1
左子树高 1、右子树高 2 → 矮的一边在左边 ✗
绿色 = 该结点为根的子树是完全二叉树;红色 = 不是
🔑
一眼看出区别:完全二叉树要求结点"从上到下、从左到右"紧密排列,所以左右子树的高度差最多是 1,而且只允许"左边更高"。
样例 1 里结点 1 的左子树更高(矮的靠右)→ 可以;样例 2 里右子树更高(矮的靠左)→ 不行。
🧮 样例 2 逐结点推演
我们用"后序"的顺序(先孩子、后自己)逐个结点算,每一步都记录三个量:高度 h、是否满 full、是否完全 cmpl。
1
结点 2(叶子)
左右孩子都是 0。按约定空子树 h=0、满=真、完全=真。
于是 h₂ = (0,0)+1 = 1;hl=hr=0 → 满 = 真,完全 = 左满 ∧ 右完全 = 真
✅ 完全 → 计数 1
2
结点 4(叶子)
同样是叶子:h₄ = 1,满 = 真,完全 = 真。
✅ 完全 → 计数 2
3
结点 3(左孩子 4,右孩子空)
取 h₄ = 1、右孩子为空 h=0 → hl = 1, hr = 0
满足 hl = hr + 1 → 完全 = 完全左 ∧ 满右 = 真 ∧ 真(空子树) = 真
h₃ = (1,0)+1 = 2;因为 hl ≠ hr,所以满 = 假
✅ 完全 → 计数 3
4
结点 1(左孩子 2,右孩子 3)
取 h₂ = 1, h₃ = 2 → hl = 1, hr = 2
先比 hl = hr?1 ≠ 2,不成立
再比 hl = hr + 1?1 ≠ 3,也不成立
→ 完全 = 假,即使结点 2、3 两棵子树都完全也没用
❌ 不完全
📊 汇总统计
结点左 · 右hl · hr高度 h满?完全?累计
2— · —0 · 01是✅ 是1
4— · —0 · 01是✅ 是2
34 · —1 · 02否✅ 是3
12 · 31 · 23否❌ 否3
最终答案:3 棵 ✓
❓ 为什么「只有左孩子」可以,「只有右孩子」不行?
这是本题最容易记混的一点,用"层序排列"的视角看就很清楚:
情形层序展开图是否完全原因
只有左孩子
父 → 左(左边填满,右边空着)
✅ 是
最后一层的结点仍然"靠左排"
只有右孩子
父 → 空 → 右(中间挖了个洞)
❌ 否
右边的位置被占了,左边却空着,不满足"靠左"
⚠️
对应到公式:只有右孩子时 hl = 0、hr ≥ 1,
既不可能满足 hl = hr,也不可能满足 hl = hr + 1,
所以自动落入"其他情况 → 完全 = 假"。公式天然处理了这个坑,不用特判。
🟠 解法一:逐棵独立判定
对每个结点,用它自己为根做一次 BFS,检查是否出现"空孩子之后又出现非空孩子"
单次判定:O(子树大小)
总复杂度:O(n²)(链状树时 ∑size = n²/2)
n = 500:约 12 万次 → 轻松通过 40%
n = 10⁵:约 5×10⁹ 次 → TLE
⚠️
同一棵子树会被反复扫描——父结点判定时又要把孩子全走一遍,做了大量重复功。
🟢 解法二:后序 DP 推荐
每个结点只算一次,把 (高度, 是否满, 是否完全) 直接交给父结点用
每个结点合并代价:O(1)
总复杂度:O(n)
n = 10⁵:约 10⁵ 次 → 稳过满分
额外空间:仅 3 个数组
💡
核心思想:子树的结论可以被父结点复用,
这就是"树形 DP"——把递归的返回值当作状态。
📈 性能对比
n 的规模逐棵判定(O(n²))后序 DP(O(n))现实结果
500(40% 测试点)约 12 万次约 500 次两者都能过
10,000约 5×10⁷ 次约 10⁴ 次尚可,已偏慢
100,000(满分要求)约 5×10⁹ 次约 10⁵ 次暴力超时,DP 稳过
🎯
比赛策略:先写 O(n²) 的暴力拿下 40% 的分,再改成后序 DP 拿满分。
本题 DP 的代码量并不比暴力多多少,时间充裕的话直接上 DP 更稳。
还有结点未访问 → 回到后序遍历
hl == hr
hl == hr + 1
其他情况
是 ✓
否 ✗
开始
读入 n、lc[]、rc[]
后序遍历访问结点 u
先递归左右孩子,取 hl、hr 与左右标记
hl 与 hr 的关系?
决定满与完全
满 = 满L 且 满R
完全 = 满L 且 完全R
满 = 假
完全 = 完全L 且 满R
满 = 假
完全 = 假
h = max(hl, hr) + 1
完全 = 真?
ans++
不计数
回溯;所有结点都访问完了?
输出 ans
结束
← 左右滑动查看完整流程图
🔑 空子树约定:让叶子"免费"通过
如果我们规定空子树的高度为 0、是满二叉树、也是完全二叉树,那么叶子结点就不用单独写分支了:
结点类型hl · hr套用公式结果
叶子(左右皆空)
0 · 0
hl == hr → 满 = 满L ∧ 满R;完全 = 满L ∧ 完全R
满 = 真,完全 = 真,h = 1 ✓
✨
这正是好写法的体现:不需要写 if (是叶子) 的特判。
统一约定边界值,代码的分支数就少一层,出错概率也低——这是树形 DP 里非常常用的技巧。
第一行输入结点数 n,接下来 n 行每行两个数表示左、右孩子编号(不存在填 0)。
输入数据
4
2 3
0 0
4 0
0 0
算一下!
随机一棵树
随机满二叉树
来一棵链(爆栈预警)
分析结果会显示在这里
点"算一下"按钮开始 →
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n;
int lc[MAXN], rc[MAXN]; // 左右孩子,0 表示空
int h[MAXN]; // 子树高度
bool full[MAXN]; // 是否满二叉树
bool cmpl[MAXN]; // 是否完全二叉树
int ans = 0;
void dfs(int u) {
if (u == 0) return; // 空子树直接返回
dfs(lc[u]); // ① 后序:先算左孩子
dfs(rc[u]); // ② 再算右孩子
// ③ 取左右子树信息;空子树的 h = 0
int hl = h[lc[u]], hr = h[rc[u]];
// 空子树视为"满"和"完全"
bool fl = (lc[u] == 0) || full[lc[u]];
bool fr = (rc[u] == 0) || full[rc[u]];
bool cl = (lc[u] == 0) || cmpl[lc[u]];
bool cr = (rc[u] == 0) || cmpl[rc[u]];
// ④ 高度:左右取较大者再加 1(叶子得到 1)
h[u] = max(hl, hr) + 1;
// ⑤ 满:两侧等高,且两侧都满
full[u] = (hl == hr) && fl && fr;
// ⑥ 完全:三种情况
if (hl == hr) cmpl[u] = fl && cr; // 等高 → 左满、右完全
else if (hl == hr + 1) cmpl[u] = cl && fr; // 左高一 → 左完全、右满
else cmpl[u] = false; // 其他 → 一定不完全
if (cmpl[u]) ans++; // ⑦ 是就计数
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &lc[i], &rc[i]);
dfs(1); // 从根出发
printf("%d\n", ans);
return 0;
}
📖 关键几行怎么看
代码作用为什么这样写
if (u == 0) return;
遇到空结点直接返回
数组下标 0 对应的 h[0] 天然是 0,模拟"空子树高度为 0"
fl = (lc[u]==0) || full[lc[u]];
把空子树当作满二叉树
不这样写就要给叶子单独开分支,代码多一层
h[u] = max(hl, hr) + 1;
求子树高度
高度由较长的那一侧决定;只有左孩子时 = hl + 1
if (hl == hr) cmpl[u] = fl && cr;
等高时判完全
两侧等高 ⇒ 最后一层从右子树开始收尾,所以左子树必须是满的,右子树只需完全
else if (hl == hr+1) cmpl[u] = cl && fr;
左高一时的完全条件
最后一层落在左子树里 ⇒ 左子树可以是"不完全但规整"的,右子树必须是满的
else cmpl[u] = false;
其余情况判假
右边比左边高,或高度差 ≥ 2 ⇒ 中间一定有空档,不可能完全
🧠
怎么记住这两个条件?画一下就知道:完全二叉树是"从左往右依次填"。
如果左右一样高,说明右边这一层也开始了,那左边就必须已经填满;
如果左边比右边高一层,说明最后一层只在左边还没填完,所以左边允许"不完全",右边必须是"满"。
⚠️ 递归深度陷阱与迭代写法
题目没有保证树是平衡的。如果输入是一条长链(1→2→3→…→n),递归深度会达到 10⁵,
C++ 默认栈空间通常只有 1~8 MB,很容易栈溢出(RE)。
有两种改法,推荐第二种(不依赖编译选项):
// 写法一:手动扩栈(Windows / 部分评测机有效)
// 在 main 开头加:#pragma comment(linker, "/STACK:268435456")
// 在 Linux 下则要编译时加 -Wl,--stack=268435456,不可控,不推荐
// 写法二(推荐):迭代求逆前序,等价于后序
vector<int> order;
stack<int> st;
st.push(1);
while (!st.empty()) {
int u = st.top(); st.pop();
if (u == 0) continue;
order.push_back(u); // 前序:父在子之前
st.push(lc[u]);
st.push(rc[u]);
}
// 逆序处理 ⇒ 每个结点被处理时,孩子早已算完
for (int i = (int)order.size() - 1; i >= 0; i--) {
int u = order[i];
// ... 与递归版完全相同的合并逻辑 ...
}
⚠️
为什么"逆前序"就是"后序"?在前序遍历里,父结点一定排在它的所有后代之前;
把序列倒过来,后代就排到了父结点之前,于是每个结点被处理时,左右孩子必然已经算完。这就是它的正确性依据。
输入树形答案考察点
1
0 0
单结点
1
最小规模,叶子必然是
2
2 0
0 0
只有左孩子
2
只有左孩子 ⇒ 仍然是完全二叉树
2
0 2
0 0
只有右孩子
1
坑!根不完全,只有结点 2 贡献 1 棵
3
2 3
0 0
0 0
3 结点满二叉树
3
满 ⇒ 完全,每层都贡献
7
2 3
4 5
6 7
0 0
0 0
0 0
0 0
7 结点完美二叉树
7
所有子树都是满的
4
2 3
0 0
4 0
0 0
样例 2
3
右边比左边高 ⇒ 根不完全
5
2 0
3 0
4 0
5 0
0 0
5 结点左链
2
反直觉:只有最后两个结点是完全的,详见下方
100000 的左链
深度 10⁵
—
递归会爆栈,必须改迭代
🔍 为什么"左链"只有 2 棵完全?
左链 1→2→3→4→5(全是左孩子)看着很"整齐",但完全二叉树不是这么定义的:
✓
结点 5(叶子)与结点 4
结点 5:叶子,完全 ✓
结点 4:hl = 1、hr = 0 → 满足 hl = hr+1 → 完全 ✓
已得 2 棵
✗
结点 3(子树 3→4→5)
hl = h_4 = 2、hr = 0
hl = hr?否。hl = hr+1?2 ≠ 1,也否
→ 完全 = 假
直观理解:一棵 3 个结点的完全二叉树应该是 根 + 左 + 右(第二层放满),
而这里第二层只有左孩子、右边空着,最后一层的结点没有"从最左边开始紧挨着排"。
✗
结点 2、结点 1
同理,高度差都超过 1,全部判假。
📌
结论:"看起来像链"的树,只有最底下两个结点能贡献完全子树。
这个例子说明:不能靠直觉判断,必须老老实实按高度差分类讨论。
🚨 易错点清单
❌
错误 1:把"满"和"完全"当成一回事
满二叉树(2^h-1 个结点)一定是完全二叉树,但完全二叉树远不止满二叉树。
样例 2 里的结点 3(只有左孩子)就是"完全但不满"的典型例子。
❌
错误 2:忘了空子树的约定
若不在读入时把空孩子统一视为"高度 0、满、完全",就会出现叶子结点漏计、
或 h[0] 取到随机值导致高度算错。
❌
错误 3:以为孩子编号一定大于父结点
题目没有这个保证。所以不能简单地"从 n 到 1 倒着算",
必须先真正遍历出树上的顺序(或用递归 / 显式栈)。
❌
错误 4:递归爆栈
链状数据下递归深度可达 10^5,必须改迭代(逆前序)或确认评测机栈空间足够。
这是本题最容易"本地能过、评测 RE"的地方。
❌
错误 5:只判断整棵树,忘了数 n 棵
答案的统计对象是每个结点各自的子树,计数要放在每个结点的合并逻辑里,
而不是最后对根结点判断一次。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁵
结点访问次数
n 次
时间为什么是 O(n)?
后序遍历中,每个非空结点恰好被访问 1 次(进入 1 次、合并 1 次)
每次合并只做常数次比较与赋值:max、两个 if 判断
总时间 = n × O(1) = O(n),没有任何重复扫描
空间都用在哪?
用途大小说明
lc[]、rc[]O(n)存左右孩子
h[]、full[]、cmpl[]O(n)每个结点的三个状态量
递归调用栈O(h)最好 O(log n),最坏(链)O(n)
迭代版额外栈O(n)用显式栈换取不爆栈
✅ n = 10⁵ 时总操作约 10⁵ 次,C++ 不到 1 毫秒,稳过满分。
// 满二叉树:高度 h ⇒ 结点数 = 2^h - 1
int fullNodes(int h) { return (1 << h) - 1; }
// 完全二叉树用"数组编号"看孩子(堆的性质)
// 下标从 1 开始:结点 i 的左孩子 2i,右孩子 2i+1
// 下标从 0 开始:结点 i 的左孩子 2i+1,右孩子 2i+2
// 判断"数组编号 = 结点编号"的情形下是否完全:
// 只需找第一个"有右孩子却没有左孩子"的结点
bool isComplete(int n) {
for (int i = 1; i <= n; i++) {
if (2i+1 <= n && 2i > n) return false;
}
return true;
}
// 树形 DP 通用套路:把"子树的答案"当返回值往上传递
🌟 举一反三
这道题训练的是"树形 DP + 边界约定",把这两块能力迁移出去,很多题都能拆解。
能力点本题怎么用还能迁移到
后序遍历先算孩子再算自己,保证合并时信息齐全树的重心、子树和、树形背包
状态三元组用一个结点的 (高度, 满, 完全) 描述整棵子树树上计数、方案数、最大独立集
空值约定空子树 = 高度 0 + 满 + 完全任何递归 DP 的边界处理
高度差分类讨论把 3 种情况穷尽,避免遗漏平衡树判定、AVL 旋转条件
🌟
思考题:
① 如果把问题改成"统计满二叉树子树的数量",三元组里的判定该怎么改?提示:判定条件会简单很多——不再需要区分"完全"。
② 如果题目不保证根是 1 号结点(例如只给 n 行孩子信息),你要怎么找出根?
提示:统计每个结点的"入度",入度为 0 的那个就是根。
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n;
int lc[MAXN], rc[MAXN]; // 左右孩子,0 表示空
int h[MAXN]; // 子树高度
bool full[MAXN]; // 是否满二叉树
bool cmpl[MAXN]; // 是否完全二叉树
int ans = 0;
void dfs(int u) {
if (u == 0) return; // 空子树直接返回
dfs(lc[u]); // ① 后序:先算左孩子
dfs(rc[u]); // ② 再算右孩子
// ③ 取左右子树信息;空子树的 h = 0
int hl = h[lc[u]], hr = h[rc[u]];
// 空子树视为"满"和"完全"
bool fl = (lc[u] == 0) || full[lc[u]];
bool fr = (rc[u] == 0) || full[rc[u]];
bool cl = (lc[u] == 0) || cmpl[lc[u]];
bool cr = (rc[u] == 0) || cmpl[rc[u]];
// ④ 高度:左右取较大者再加 1(叶子得到 1)
h[u] = max(hl, hr) + 1;
// ⑤ 满:两侧等高,且两侧都满
full[u] = (hl == hr) && fl && fr;
// ⑥ 完全:三种情况
if (hl == hr) cmpl[u] = fl && cr; // 等高 → 左满、右完全
else if (hl == hr + 1) cmpl[u] = cl && fr; // 左高一 → 左完全、右满
else cmpl[u] = false; // 其他 → 一定不完全
if (cmpl[u]) ans++; // ⑦ 是就计数
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &lc[i], &rc[i]);
dfs(1); // 从根出发
printf("%d\n", ans);
return 0;
}// 写法一:手动扩栈(Windows / 部分评测机有效)
// 在 main 开头加:#pragma comment(linker, "/STACK:268435456")
// 在 Linux 下则要编译时加 -Wl,--stack=268435456,不可控,不推荐
// 写法二(推荐):迭代求逆前序,等价于后序
vector<int> order;
stack<int> st;
st.push(1);
while (!st.empty()) {
int u = st.top(); st.pop();
if (u == 0) continue;
order.push_back(u); // 前序:父在子之前
st.push(lc[u]);
st.push(rc[u]);
}
// 逆序处理 ⇒ 每个结点被处理时,孩子早已算完
for (int i = (int)order.size() - 1; i >= 0; i--) {
int u = order[i];
// ... 与递归版完全相同的合并逻辑 ...
}// 满二叉树:高度 h ⇒ 结点数 = 2^h - 1
int fullNodes(int h) { return (1 << h) - 1; }
// 完全二叉树用"数组编号"看孩子(堆的性质)
// 下标从 1 开始:结点 i 的左孩子 2i,右孩子 2i+1
// 下标从 0 开始:结点 i 的左孩子 2i+1,右孩子 2i+2
// 判断"数组编号 = 结点编号"的情形下是否完全:
// 只需找第一个"有右孩子却没有左孩子"的结点
bool isComplete(int n) {
for (int i = 1; i <= n; i++) {
if (2*i+1 <= n && 2*i > n) return false;
}
return true;
}
// 树形 DP 通用套路:把"子树的答案"当返回值往上传递②编程打卡 · 点一下就能勾选
- 完成 P17013《满二叉树》,跑通全部样例
- 完成 P17458《分树规划》,跑通全部样例
- 完成 B3874《小杨的握手问题》,跑通全部样例
- 完成 P14919《路径覆盖》,跑通全部样例
- 完成 P15801《完全二叉树》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
贪心与排序应用
①本日知识点 · 贪心与排序应用
贪心的正确性要么能证明,要么能举不出反例——考试时优先验证。
本组 2 道题全部来自 GESP 真题,按「贪心与排序应用」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
小杨对于 m 种算法的初始掌握程度均为 0。第 i 道题目有对应的知识点 a_i,即学习第 i 道题目可以令小杨对第 a_i 种算法的掌握程度提高 b_i。小杨的学习目标是对于 m 种算法的掌握程度均至少为 k。
小杨认为连续学习两道相同知识点的题目是不好的,小杨想请你编写程序帮他计算出他最少需要学习多少道题目才能使得他在完成学习目标的同时避免连续学习两道相同知识点的题目。
第二行 n 个正整数 a_1, a_2, ..., a_n,代表每道题目的知识点。
第三行 n 个正整数 b_1, b_2, ..., b_n,代表每道题目提升的掌握程度。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 5 10 1 1 2 3 3 9 1 10 10 1 | 4 |
| 2 | 2 4 10 1 1 1 2 1 2 7 10 | -1 |
一种最优学习顺序为第一道题,第三道题,第四道题,第二道题。
数据规模与约定
| 子任务编号 | 数据点占比 | m | n | b_i | k |
| :-: | :-: | :-: | :-: | :-: | :-: |
| 1 | 30% | 2 | ≤q 9 | ≤q 10 | ≤q 10 |
| 2 | 30% | ≤q 9 | ≤q 9 | ≤q 10 | ≤q 10 |
| 3 | 40% | ≤q 10^5 | ≤q 10^5 | ≤q 10^5 | ≤q 10^5 |
对于全部数据,保证有 1 ≤q m, n, b_i, k ≤q 10^5,1 ≤q a_i ≤q m。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
有 m 种算法,初始掌握度都是 0。有 n 道题,第 i 道题属于知识点 aᵢ,学习后能让该算法的掌握度提高 bᵢ。每道题最多学一次。
目标是让每种算法的掌握度都至少为 k,同时不能连续学习两道相同知识点的题目。求最少需要学习多少道题;无解输出 -1。
💡人话翻译:分两步——
① 每种算法各自"用最少的题达标":把该知识点的题目按 b 从大到小排,取前缀直到和 ≥ k,这个数量记为 base_j。
② 解决"不能连续同知识点":经典结论——若某种算法选了 cnt 道题,总量为 T,则能交错排开 ⟺ 最大 cnt ≤ T − 最大 cnt + 1。
🔍 关键词提取
分组贪心交错排列可行性排序取前缀总数与最大值
已知条件
项目说明
输入第一行 m、n、k;第二行 a₁…aₙ;第三行 b₁…bₙ
输出最少题目数,无解输出 −1
数据范围1 ≤ m, n, bᵢ, k ≤ 10⁵
约束 1每种算法掌握度都要 ≥ k
约束 2不能连续两道题属于同一知识点
需要解决的问题
先判无解:若某种算法的所有题目 b 之和都 < k,那它永远达不到 k → 输出 −1
怎么让每题都"最有用"?同一种算法的题,当然优先做 b 大的——这样用的题数最少
交错条件怎么用?设选了 T 道题、某种算法占了 M 道,则要求 M ≤ T − M + 1;若不满足,就多选一些别知识点的题把 T 撑大
📊 第一步
同知识点题按 b 降序
取前缀直到和 ≥ k
得到 base_j(最少题数)
若总和 📐 第二步
设 M = max base_j
T0 = Σ base_j
交错条件:M ≤ T − M + 1
即 T ≥ 2M − 1
🔧 第三步
T = max(T0, 2M − 1)
需要"多选题"把 T 撑到这么大
每种算法最多贡献 min(sz_j, M) 道
若 Σ min(sz_j, M) ⚠️ 易错点
忘记先判 -1
同知识点没按 b 降序取前缀
交错条件写反
忽略"每题只能学一次"的容量上限
知识点 a = [1, 1, 2, 3, 3],提升量 b = [9, 1, 10, 10, 1]。
1
按知识点分组,并各自降序
算法 1:题目 b = {9, 1} → 降序 [9, 1],总和 10
算法 2:题目 b = {10} → [10],总和 10
算法 3:题目 b = {10, 1} → 降序 [10, 1],总和 11
三组都 ≥ k = 10 ✓
2
求各组的 base
算法 1:[9] 才 9 < 10,[9, 1] = 10 ≥ 10 → base₁ = 2
算法 2:[10] = 10 ≥ 10 → base₂ = 1
算法 3:[10] = 10 ≥ 10 → base₃ = 1
base = (2, 1, 1)
3
检查交错条件
T0 = 2 + 1 + 1 = 4
M = max(2, 1, 1) = 2
要求 M ≤ T0 − M + 1,即 2 ≤ 4 − 2 + 1 = 3 ✓ 成立
所以 T = max(4, 2×2−1) = max(4, 3) = 4
T = 4
4
验证容量
各组题目总数 sz = (2, 1, 2)
Σ min(sz_j, M) = min(2,2) + min(1,2) + min(2,2)
= 2 + 1 + 2 = 5 ≥ T = 4 ✓
所以可行
✅ 答案 4
一种方案:题目 1、3、4、2 → 知识点 1、2、3、1 ✓ 无连续相同
🔑注意算法 1 必须做两道题:它最大的题只给 9 分(< 10),所以必须再做一道 b=1 的。这就是为什么"按 b 降序取前缀"很重要——如果先做 b=1 的,会误以为要 3 道题。
🧮 样例 2:为什么是 -1
m = 2,n = 4,k = 10,a = [1, 1, 1, 2],b = [1, 2, 7, 10]。
1
分组与 base
算法 1:b = {1, 2, 7} → 降序 [7, 2, 1],总和 10 ≥ 10 ✓
7 + 2 = 9 < 10;7 + 2 + 1 = 10 → base₁ = 3
算法 2:b = {10} → base₂ = 1
base = (3, 1)
2
检查交错条件
T0 = 3 + 1 = 4,M = 3
要求 T ≥ 2M − 1 = 5
所以 T = max(4, 5) = 5
但两组总共只有 4 道题(sz = (3, 1))
需要 5 道但只有 4 道
3
结论
Σ min(sz_j, M) = min(3,3) + min(1,3) = 3 + 1 = 4
4 < T = 5 → 无法凑够
所以输出 -1
❌ 输出 -1
📊 直观理解
算法 1 必须做 3 道题(因为它的题给分太碎),而算法 2 只有 1 道题。要想让 3 道"1 类题"不挨在一起,中间必须插入至少 2 道其他题,但其他知识点总共只有 1 道——插不满,所以无解。
⚠️交错条件的直觉:把最多的那类题想象成"隔板",要让它们两两不相邻,就需要在它们之间插入至少 M − 1 道别的题;而别的题共有 (T − M) 道。所以条件就是 M − 1 ≤ T − M,即 T ≥ 2M − 1 ✓。这个"插空"思路和"座位安排""重排字符串"是同一个模型。
🟢 分组 + 判定(推荐) 推荐
每组各自取最少的题达标,再用交错条件判定并"补题"
时间 O(n log n)
n = 10⁵ 时约 10⁶
代码 40 行
空间 O(n + m)
💡三个关键量:base_j(每组最少题数)、M = max base_j、sz_j(每组题目总数)。答案或 -1 完全由这三个量决定,不需要真的去排列题目。
🟠 搜索学习顺序
枚举题目的学习顺序并检查条件
n! 种顺序
n = 10⁵ 完全不可行
只能处理 n ≤ 9 的测试点
不适合
⚠️为什么不需要搜索:因为"能否交错"只取决于每类的数量,与具体顺序无关(这是经典的排列存在性结论)。识别出"只需判断数量关系"是本题的关键一步。
📈 性能对比
方案复杂度可行性
分组 + 判定O(n log n)✅ 稳过
枚举顺序O(n!)❌ 不可行
第一行输入 m n k,第二行输入知识点,第三行输入提升量。
输入数据3 5 10
1 1 2 3 3
9 1 10 10 1
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, k;
scanf("%d %d %d", &m, &n, &k);
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
vector<vector<long long>> g(m + 1); // 按知识点分组
for (int i = 0; i < n; i++) {
long long b;
scanf("%lld", &b);
g[a[i]].push_back(b);
}
long long T0 = 0;
int M = 0;
vector<int> base(m + 1), sz(m + 1);
for (int j = 1; j <= m; j++) {
sort(g[j].begin(), g[j].end(), greater<long long>()); // 降序
sz[j] = (int)g[j].size();
long long s = 0;
int cnt = 0;
for (int t = 0; t < (int)g[j].size(); t++) {
if (s >= k) break;
s += g[j][t];
cnt++;
}
if (s < k) { puts("-1"); return 0; } // 该算法永远达不到 k
base[j] = cnt;
T0 += cnt;
M = max(M, cnt);
}
long long T = max(T0, 2LL * M - 1); // 交错条件要求的下界
// 每种算法最多贡献 min(sz[j], M) 道(受交错条件限制)
long long capSum = 0;
for (int j = 1; j <= m; j++) capSum += min((long long)sz[j], (long long)M);
if (capSum < T) puts("-1");
else printf("%lld\n", T);
return 0;
}
🔑为什么"最多贡献 min(sz_j, M)"?一方面不能超过该知识点的题目总数 sz_j;另一方面,若某一类超过 M = floor((T+1)/2),它就变成"绝对多数",必然出现连续两道同类题。
所以每类的上限是两者取小。把"总数 T"和"每类上限"对齐后,问题就变成"能否凑出恰好 T 道题"——只要总和上限够,就一定能凑(因为从 base 往上加是连续的)。
📖 关键几行怎么看
代码作用为什么这样写
sort(g[j], greater)组内降序优先用大 b 的题,题数最少
if (s < k) return -1无解判定该算法所有题加起来都不够
T = max(T0, 2M - 1)交错下界多数类必须能被其他类"插开"
capSum += min(sz[j], M)容量上限每类题数既受总数限制也受 M 限制
if (capSum < T) -1最终判定凑不出这么多题就无解
⚠️四个坑:① 忘记先判"某算法总和 < k"的无解情况;② 组内忘记降序(会导致 base 偏大);③ 交错条件写成 M ≤ T − M(应为 M ≤ T − M + 1,差一个 1 就会错);④ 忽略 min(sz_j, M) 的上限。
写完程序后,用这些数据自查一遍:
输入答案考察点
3 5 10
1 1 2 3 3
9 1 10 10 14题面样例 1
2 4 10
1 1 1 2
1 2 7 10-1题面样例 2(插不满)
1 1 5
1
51一种算法一道题,恰好达标
1 2 5
1 1
3 3-1只有一种算法,需要 2 道题就会连续同类
2 2 5
1 2
5 52两种算法各一道,可交错
2 3 3
1 1 2
2 2 53base=(2,1),M=2,T=3;交错可行 → 3 道
✅自查清单:① 组内降序了吗?② 交错条件对吗?③ 检查了每题只能用一次吗?
🚨 易错点清单
⚠️组内不排序:必须按 b 降序取前缀,否则 base 偏大。
⚠️交错条件差一个 1:应为 M ≤ T − M + 1。
⚠️忘记判无解:某算法总和 < k 时直接输出 −1。
时间复杂度
O(n log n)
空间复杂度
O(n + m)
n 最大
10⁵
运算量
约 2 × 10⁶
时间怎么算的?
分组 O(n)
每组排序:Σ sz_j log sz_j ≤ n log n
求 base 与判定 O(n + m)
空间都用在哪?
需要存下每组的题目提升量。
✅ 约 200 万次操作,瞬间完成。本题难点在"想到交错条件",而不在复杂度。
// 本题的三个核心量
// base_j : 第 j 种算法"用最少题达标"需要的题数
// M : max base_j(多数类的规模)
// T : 实际需要学习的总题数 = max(Σbase_j, 2M - 1)
// "不能连续同类"的通用判定(重排字符串模型)
// 设有若干类元素,数量为 cnt_1..cnt_m,总数 T
// 能排成"相邻不同"的排列 <=> max cnt_i <= T - max cnt_i + 1
// 等价于 T >= 2 * max cnt_i - 1
// 这个结论的直觉(插空法)
// 把最多的那一类当作隔板,需要插入至少 (M - 1) 个其他元素
// 其他元素有 (T - M) 个,所以要求 M - 1 <= T - M
// 类似题目
// - 重排字符串使相邻字符不同(LeetCode 767)
// - 任务调度器 / 相同任务间隔冷却
// - 分组后交错排列的所有问题
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
插空法多数类作隔板所有"相邻不能相同"的排列问题
分组贪心组内降序取前缀"用最少资源达标"类问题
上界判定min(sz_j, M) 之和能否凑够所需的题数
🌟思考题:如果题目改成"不能连续学习三道同知识点的题"(允许连续两道相同),交错条件会怎么变?(提示:那就变成"多数类最多只能占 2 × (其他 + 1)",即 M ≤ 2(T − M + 1)。把"允许的连续长度"从 1 改成 2,条件里的系数就相应变化——这也是"任务调度器"类问题的常见变体。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, k;
scanf("%d %d %d", &m, &n, &k);
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
vector<vector<long long>> g(m + 1); // 按知识点分组
for (int i = 0; i < n; i++) {
long long b;
scanf("%lld", &b);
g[a[i]].push_back(b);
}
long long T0 = 0;
int M = 0;
vector<int> base(m + 1), sz(m + 1);
for (int j = 1; j <= m; j++) {
sort(g[j].begin(), g[j].end(), greater<long long>()); // 降序
sz[j] = (int)g[j].size();
long long s = 0;
int cnt = 0;
for (int t = 0; t < (int)g[j].size(); t++) {
if (s >= k) break;
s += g[j][t];
cnt++;
}
if (s < k) { puts("-1"); return 0; } // 该算法永远达不到 k
base[j] = cnt;
T0 += cnt;
M = max(M, cnt);
}
long long T = max(T0, 2LL * M - 1); // 交错条件要求的下界
// 每种算法最多贡献 min(sz[j], M) 道(受交错条件限制)
long long capSum = 0;
for (int j = 1; j <= m; j++) capSum += min((long long)sz[j], (long long)M);
if (capSum < T) puts("-1");
else printf("%lld\n", T);
return 0;
}// 本题的三个核心量 // base_j : 第 j 种算法"用最少题达标"需要的题数 // M : max base_j(多数类的规模) // T : 实际需要学习的总题数 = max(Σbase_j, 2M - 1) // "不能连续同类"的通用判定(重排字符串模型) // 设有若干类元素,数量为 cnt_1..cnt_m,总数 T // 能排成"相邻不同"的排列 <=> max cnt_i <= T - max cnt_i + 1 // 等价于 T >= 2 * max cnt_i - 1 // 这个结论的直觉(插空法) // 把最多的那一类当作隔板,需要插入至少 (M - 1) 个其他元素 // 其他元素有 (T - M) 个,所以要求 M - 1 <= T - M // 类似题目 // - 重排字符串使相邻字符不同(LeetCode 767) // - 任务调度器 / 相同任务间隔冷却 // - 分组后交错排列的所有问题
每次运送物资时,货车从初始运输站点出发,前往 A 市或 B 市,之后返回初始运输站点。A 市、B 市和运输站点的位置可以视作数轴上的三个点,其中 A 市的坐标为 0,B 市的坐标为 x,运输站点的坐标为 p 且有 0 \lt p \lt x。货车每次去 A 市运送物资的总行驶路程为 2p,去 B 市运送物资的总行驶路程为 2(x - p)。
对于第 i 个运输站点,其位置为 p_i 且至多作为 c_i 辆车的初始运输站点。小杨想知道,在最优分配每辆货车的初始运输站点的情况下,所有货车每天的最短总行驶路程是多少。
之后 n 行,每行包含两个正整数 p_i 和 c_i,代表第 i 个运输站点的位置和最多容纳车辆数。
之后 m 行,每行包含两个正整数 a_i 和 b_i,代表第 i 辆货车每天需要向 A 市运送 a_i 次物资,向 B 市运送 b_i 次物资。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 4 10 1 1 2 1 8 3 5 3 7 2 9 0 1 10000 | 40186 |
| 子任务编号 | 数据点占比 | n | x | c_i |
| :--------: | :--------: | :---------: | :---------: | :---------: |
| 1 | 20% | 2 | 2 | 1 |
| 2 | 20% | ≤q 10^5 | ≤q 10^5 | 1 |
| 3 | 60% | ≤q 10^5 | ≤q 10^5 | ≤q 10^5 |
对于全部数据,保证有 1≤q n,m≤q 10^5,2≤q x≤q 10^8,0\lt p_i\lt x,1≤q c_i≤q 10^5,0≤q a_i,b_i≤q 10^5。数据保证 Σ c_i≥q m。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
数轴上有 A 市(坐标 0)和 B 市(坐标 x),之间有 n 个运输站点,第 i 个在坐标 pᵢ,最多容纳 cᵢ 辆车。有 m 辆货车,第 i 辆每天要向 A 市送 aᵢ 次、向 B 市送 bᵢ 次。货车从自己的站点出发、送达后返回,去 A 市的单次往返路程是 2p,去 B 市是 2(x − p)。
求最优分配下所有货车的最短总路程。
💡人话翻译:先把"每辆车的成本"写成关于站点的式子:
cost(p) = 2p·a + 2(x−p)·b = 2p(a − b) + 2x·b。
注意 2x·b 与站点无关,是固定开销;真正要优化的是 2p(a − b)。
于是——系数 (a−b) 越大的车,越应该放在 p 越小的站点。排序后贪心分配即可。
🔍 关键词提取
成本拆解排序贪心容量约束Monge 性质
已知条件
项目说明
输入第一行 n、m、x;随后 n 行 pᵢ、cᵢ;再随后 m 行 aᵢ、bᵢ
输出最短总路程
坐标0 < pᵢ < x
容量站点 i 最多放 cᵢ 辆车
目标最小化总路程
需要解决的问题
成本怎么化简?2p·a + 2(x−p)·b = 2p(a−b) + 2x·b;后半部分是常数
贪心策略是什么?把货车按 d = a − b 从大到小排序,把站点按 p 从小到大排序,然后依次"填满"站点容量
为什么这样的配对最优?成本矩阵 d_i × p_j 满足"越大配越小"的单调性,可以用交换论证证明
📐 成本化简
cost = 2pa + 2(x−p)b
= 2p(a−b) + 2xb
2xb 与站点无关(常数)
只需优化 2p(a−b)
🔑 贪心依据
d = a − b 是"斜率"
d 大 → 希望 p 小
d 小(负)→ 希望 p 大
故 d 降序配 p 升序
⚙️ 实现
货车按 d 降序排序
站点按 p 升序排序
依次填满容量
累加 2p·d,再加上常数 2xb
⚠️ 易错点
忘记加常数项 2xb
排序方向搞反
用 int(路程可达 10¹⁵)
容量没减到 0 就跳到下一个站点
站点:(p=1, c=1)、(p=2, c=1)、(p=8, c=3)。
货车(aᵢ, bᵢ):(5,3)、(7,2)、(9,0)、(1,10000)。
1
第 1 步:算每辆车的 d = a − b
车 1:5 − 3 = 2
车 2:7 − 2 = 5
车 3:9 − 0 = 9
车 4:1 − 10000 = −9999
d = [9, 5, 2, −9999](降序)
2
第 2 步:站点按 p 升序
p = 1(容量 1)
p = 2(容量 1)
p = 8(容量 3)
按 p 从小到大填
3
第 3 步:依次分配
d = 9 的车 → p = 1(容量用尽)
d = 5 的车 → p = 2(容量用尽)
d = 2 的车 → p = 8(剩 2)
d = −9999 的车 → p = 8(剩 1)
分配完成
4
第 4 步:算变动的部分 Σ 2p·d
2 × (1×9 + 2×5 + 8×2 + 8×(−9999))
= 2 × (9 + 10 + 16 − 79992)
= 2 × (−79957) = −159914
−159914
5
第 5 步:加常数 Σ 2x·b
b 之和 = 3 + 2 + 0 + 10000 = 10005
2 × 10 × 10005 = 200100
常数项 200100
📊 汇总
货车abd = a−b分到站点 p贡献 2p·d
3909118
2725220
1532832
4110000−99998−159984
−159914 + 200100 = 40186 ✓
🔑注意第 4 辆车的作用:它的 d = −9999 极小,所以应该放在最右边(p 最大)的站点——这样 2p·d 才最负,把总成本压下来。
直观理解:它主要往 B 市送(b = 10000),所以站点越靠近 B(p 越大)越省。贪心规则与直觉完全一致。
🧮 为什么"大 d 配小 p"最优
用交换论证来证明。
1
假设有两辆车 i、j 和两个站点 S、T
设 d_i > d_j 且 p_S < p_T
现在的分配是"i 在 T、j 在 S"(违背规则)
该分配贡献 = 2(d_i·p_T + d_j·p_S)
当前成本
2
交换后
改成"i 在 S、j 在 T"
新贡献 = 2(d_i·p_S + d_j·p_T)
两者之差 = 2(d_i·p_S + d_j·p_T − d_i·p_T − d_j·p_S)
= 2(d_i − d_j)(p_S − p_T)
差值计算
3
判断符号
因为 d_i > d_j,所以 (d_i − d_j) > 0
又因为 p_S < p_T,所以 (p_S − p_T) < 0
所以差值 < 0 ——即交换后总成本更小
所以"违背规则"的分配一定不是最优
✅ 得证
⚠️这就是"排序贪心"最常用的证明套路:任取两个"逆序"的元素,证明交换它们不会让答案变差,从而说明"有序配对"是最优的。
同时也要注意:本题必须遵守容量限制,所以不能"自由配对",而是"按顺序把容量填满"——排序后的顺次填充恰好实现了最优配对。
🟢 排序贪心(推荐) 推荐
货车按 d 降序、站点按 p 升序,顺次填容量
时间 O((n+m) log(n+m))
n, m ≤ 10⁵ 时约 3 × 10⁶
代码 30 行
有交换论证保证
💡实现要点:排序后用一个指针扫描站点,while (容量 > 0 且 还有货车) 分配,容量减到 0 就换下一个站点。注意累加时要分开处理"变动项"和"常数项",减少出错概率。
🟠 建模成最小费用流
货车为源、站点为汇,容量为边权,跑费用流
理论正确
O(nm) 级别的复杂度
n, m = 10⁵ 时完全不可行
属于"用重武器打小怪"
⚠️为什么贪心就够:本题的成本矩阵是 d_i × p_j 的乘积形式,这种特殊结构使得"排序配对"必然最优。如果成本是任意的矩阵,就真的需要网络流了——所以"识别成本结构"是本题的关键。
📈 性能对比
方案复杂度可行性
排序贪心O((n+m) log(n+m))✅ 稳过
最小费用流至少 O(nm)❌ 规模太大
第一行输入 n m x,随后 n 行站点,再随后 m 行货车。
输入数据3 4 10
1 1
2 1
8 3
5 3
7 2
9 0
1 10000
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
struct Station { long long p, c; };
struct Truck { long long a, b, d; };
int main() {
int n, m;
long long x;
scanf("%d %d %lld", &n, &m, &x);
vector<Station> st(n);
for (int i = 0; i < n; i++) scanf("%lld %lld", &st[i].p, &st[i].c);
vector<Truck> tr(m);
long long base = 0; // 与站点无关的常数项
for (int i = 0; i < m; i++) {
scanf("%lld %lld", &tr[i].a, &tr[i].b);
tr[i].d = tr[i].a - tr[i].b; // 关键系数
base += 2 * x * tr[i].b;
}
// 货车按 d 降序
sort(tr.begin(), tr.end(), [](const Truck &u, const Truck &v) {
return u.d > v.d;
});
// 站点按 p 升序
sort(st.begin(), st.end(), [](const Station &u, const Station &v) {
return u.p < v.p;
});
long long vary = 0;
int j = 0;
for (int i = 0; i < m; i++) {
while (j < n && st[j].c == 0) j++; // 找下一个还有容量的站点
if (j >= n) break; // 题目保证有解,这里作保险
vary += 2 * st[j].p * tr[i].d;
st[j].c--;
}
printf("%lld\n", base + vary);
return 0;
}
🔑为什么要把成本拆成两项?2p·a + 2(x−p)·b 直接看不好比较,但写成 2p(a−b) + 2x·b 后结构就清楚了:第二项完全不受站点影响,第一项则是"系数 (a−b) 乘以坐标 p"。
于是问题化为"把一组系数与一组坐标配对,使系数×坐标之和最小"——这正是"大配小"排序贪心的标准形式。
📖 关键几行怎么看
代码作用为什么这样写
tr[i].d = a - b关键系数成本的"斜率",决定该车想去哪一端
base += 2 * x * b常数项与站点无关,先拿出来
sort(tr, d 降序)货车排序d 大 → 想放左边
sort(st, p 升序)站点排序从小坐标开始填
while (st[j].c == 0) j++换站点当前站点容量用尽就往后找
⚠️四个坑:① 忘记加常数项 2xb;② 两个排序方向搞反(货车应降序、站点应升序);③ 用 int(路程可达 10¹⁵ 量级);④ 分配时忘记扣减容量。
写完程序后,用这些数据自查一遍:
输入答案考察点
3 4 10
1 1 / 2 1 / 8 3
5 3 / 7 2 / 9 0 / 1 1000040186题面样例
1 1 10
5 1
1 120d = 0,故仅剩常数项 2×10×1 = 20
1 1 10
5 1
0 00不需要运送,路程为 0
2 1 10
3 1 / 7 1
5 030d = 5 应放最小的 p = 3:2×3×5 = 30
2 2 10
3 1 / 7 1
5 0 / 5 0100两辆车相同,各自分配到站点
✅自查清单:① 加了常数项吗?② 两个排序方向对吗?③ 扣减容量了吗?
🚨 易错点清单
⚠️忘记常数项:2x·b 与站点无关,必须加上。
⚠️排序方向反:货车 d 降序、站点 p 升序。
⚠️用 int:总路程可达 10¹⁵,需要 long long。
时间复杂度
O((n+m) log(n+m))
空间复杂度
O(n + m)
n, m 最大
10⁵
运算量
约 3 × 10⁶
时间怎么算的?
排序货车与站点:O(n log n + m log m)
一次线性扫描填容量:O(n + m)
合计 O((n+m) log(n+m))
空间都用在哪?
存站点与货车信息,各 O(n)、O(m)。
✅ 约 300 万次操作,瞬间完成。关键是把"分配问题"化简成"排序配对",避免网络流。
// 本题的核心化简
// cost(p) = 2p·a + 2(x-p)·b
// = 2p(a-b) + 2x·b
// 前半部分随 p 变化,后半部分是常数
// -> 变成"系数 d=a-b 与坐标 p 的配对问题"
// 排序配对的通用结论
// 要使 Σ d_i * p_{σ(i)} 最小:
// d 升序 配 p 降序(即 d 大的配 p 小的)
// 要使 Σ d_i * p_{σ(i)} 最大:
// d 升序 配 p 升序
// 交换论证模板(证明贪心正确性)
// 取任意一对"逆序"元素 i, j(d_i > d_j 但 p_i < p_j 却被反配)
// 交换后成本变化 = (d_i - d_j)(p_i - p_j)
// 由 d_i > d_j 且 p_i < p_j 得变化量为负 -> 交换更优
// 所以最优解必然"有序配对"
// 带容量约束时:排序后"顺次填满容量"即可
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
成本拆解分离"常数项"和"可优化项"所有线性成本优化问题
排序配对大配小 / 大配大分配问题、匹配问题
交换论证证明贪心的正确性所有贪心算法的验证
🌟思考题:如果题目变成"每个站点没有容量限制",答案会怎样?(提示:更简单——每辆车各自选择使自己成本最小的站点:d > 0 就选最小的 p,d < 0 就选最大的 p,d = 0 随便。完全不需要排序。正是"容量限制"让问题变成"排序 + 填容量",这也是本题的难度所在。)
#include <bits/stdc++.h>
using namespace std;
struct Station { long long p, c; };
struct Truck { long long a, b, d; };
int main() {
int n, m;
long long x;
scanf("%d %d %lld", &n, &m, &x);
vector<Station> st(n);
for (int i = 0; i < n; i++) scanf("%lld %lld", &st[i].p, &st[i].c);
vector<Truck> tr(m);
long long base = 0; // 与站点无关的常数项
for (int i = 0; i < m; i++) {
scanf("%lld %lld", &tr[i].a, &tr[i].b);
tr[i].d = tr[i].a - tr[i].b; // 关键系数
base += 2 * x * tr[i].b;
}
// 货车按 d 降序
sort(tr.begin(), tr.end(), [](const Truck &u, const Truck &v) {
return u.d > v.d;
});
// 站点按 p 升序
sort(st.begin(), st.end(), [](const Station &u, const Station &v) {
return u.p < v.p;
});
long long vary = 0;
int j = 0;
for (int i = 0; i < m; i++) {
while (j < n && st[j].c == 0) j++; // 找下一个还有容量的站点
if (j >= n) break; // 题目保证有解,这里作保险
vary += 2 * st[j].p * tr[i].d;
st[j].c--;
}
printf("%lld\n", base + vary);
return 0;
}// 本题的核心化简
// cost(p) = 2p·a + 2(x-p)·b
// = 2p(a-b) + 2x·b
// 前半部分随 p 变化,后半部分是常数
// -> 变成"系数 d=a-b 与坐标 p 的配对问题"
// 排序配对的通用结论
// 要使 Σ d_i * p_{σ(i)} 最小:
// d 升序 配 p 降序(即 d 大的配 p 小的)
// 要使 Σ d_i * p_{σ(i)} 最大:
// d 升序 配 p 升序
// 交换论证模板(证明贪心正确性)
// 取任意一对"逆序"元素 i, j(d_i > d_j 但 p_i < p_j 却被反配)
// 交换后成本变化 = (d_i - d_j)(p_i - p_j)
// 由 d_i > d_j 且 p_i < p_j 得变化量为负 -> 交换更优
// 所以最优解必然"有序配对"
// 带容量约束时:排序后"顺次填满容量"即可②编程打卡 · 点一下就能勾选
- 完成 P11247《算法学习》,跑通全部样例
- 完成 P11376《运送物资》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
模拟与综合
①本日知识点 · 模拟与综合
把规则拆成状态 + 转移,一步一步写,别急着优化。
本组 1 道题全部来自 GESP 真题,按「模拟与综合」归在一起练。题面取洛谷原题(含公式与样例),题解取美力程 GESP 题解库(思路 + 参考代码 + 复杂度)。
小杨会从节点 s 开始在二叉树上移动,每次移动为以下三种移动方式的任意一种:
- 第 1 种移动方式:如果当前节点存在父亲节点,向上移动到当前节点的父节点,否则不移动;
- 第 2 种移动方式:移动到当前节点的左儿子;
- 第 3 种移动方式:移动到当前节点的右儿子。
小杨想知道移动 n 次后自己所处的节点编号。数据保证最后所处的节点编号不超过 10^{12}。
第二行包含一个长度为 n 且仅包含大写字母 \tt{U}、\tt{L} 和 \tt{R} 的字符串,代表每次移动的方式,其中 \tt{U} 代表第 1 种移动方式,\tt{L} 代表第 2 种移动方式,\tt{R} 代表第 3 种移动方式。
| # | 输入 | 输出 |
|---|---|---|
| 1 | 3 2 URR | 7 |
| 子任务编号 | 数据点占比 | n | s |
| :--------: | :--------: | :---------: | :------------: |
| 1 | 20% | ≤q 10 | ≤q 2 |
| 2 | 20% | ≤q 50 | ≤q 10 |
| 3 | 60% | ≤q 10^6 | ≤q 10^{12} |
对于全部数据,保证有 1≤q n≤q 10^6,1≤q s≤q 10^{12}。
💡 查看题解(思路 + 参考代码 + 复杂度) 美力程 GESP 题解库
有一棵包含无穷节点的完全二叉树:根结点编号 1,结点 i 的左儿子是 2i、右儿子是 2i+1,父结点是 ⌊i/2⌋。
从结点 s 出发,按长度为 n 的指令串移动,每次是三种之一:
U:向上到父结点;若已在根(无父结点)则原地不动
L:移动到左儿子
R:移动到右儿子
求 n 次移动后的结点编号(保证最终编号不超过 10¹²)。
💡人话翻译:直接按指令逐条模拟就行。
U → s /= 2(整除);L → s = 2s;R → s = 2s + 1。
唯一要注意的是"在根时 U 不动"这个边界,以及编号可能达到 10¹² 量级(必须用 long long)。
🔍 关键词提取
完全二叉树编号父子关系公式逐指令模拟边界处理
已知条件
项目说明
输入第一行 n、s;第二行长度 n 的指令串
输出最终结点编号
数据范围1 ≤ n ≤ 10⁶,1 ≤ s ≤ 10¹²
指令仅含大写字母 U、L、R
保证最终结点编号 ≤ 10¹²
需要解决的问题
编号关系是什么?结点 i 的左儿子 2i、右儿子 2i+1、父结点 i/2——这正是完全二叉树的顺序存储编号方式
复杂度够吗?n ≤ 10⁶,逐条模拟就是 O(n) ✓
有什么边界?当 s = 1 时执行 U 应当原地不动(因为根没有父结点)
🔢 编号规则
根 = 1
左儿子 = 2i
右儿子 = 2i+1
父结点 = ⌊i/2⌋
🔁 三种操作
U:s 整除 2
L:s 变成 2s
R:s 变成 2s+1
逐条模拟
🧠 巧妙理解
编号的二进制形式 = 路径
1 表示根
后面每位:0 是左、1 是右
如 13 = 1101 → 根-右-左-右
⚠️ 易错点
用 int(s 可达 10¹²)
s = 1 时 U 没有原地不动
把 L、R 写成 2s、2s+1 时溢出
读入指令串长度不对
一步步模拟。
1
起点:结点 2
2 的二进制是 10₂
s = 2
2
第 1 步 U(向上)
2 有父结点(因为 2 > 1)
s = 2 / 2 = 1
现在到了根
s = 1
3
第 2 步 R(右儿子)
s = 2 × 1 + 1 = 3
s = 3
4
第 3 步 R(右儿子)
s = 2 × 3 + 1 = 7
s = 7
最终 7 ✓(路径 2 → 1 → 3 → 7)
🔑编号的二进制形式就是"从根出发的路径":把编号写成二进制,去掉最高位的那个 1,剩下的位从左到右依次表示"往左(0)还是往右(1)"。
例如 7 = 111₂:去掉最高位 1 得 11,表示"右、右"——正好对应路径 1 → 3 → 7 ✓。这个理解能帮你快速心算任意编号的位置。
🧮 边界与溢出验证
这两点是本题唯一的坑。
情形输入结果说明
在根执行 Un=1, s=1, "U"1根没有父结点,原地不动
连续 U 到根后再 Un=3, s=4, "UUU"14 → 2 → 1 → 1(第三次不动)
编号变大n=40, s=1, "R"×402⁴⁰ − 1需要用 long long(约 10¹²)
1
4 → 2 → 1 → 1 的逐步过程
起点 4
第 1 个 U:4/2 = 2
第 2 个 U:2/2 = 1
第 3 个 U:s = 1,已在根 → 不移动
结果 1
✅ 1
2
为什么必须用 long long?
s 本身可达 10¹²
执行一次 R:2s + 1 可达约 2 × 10¹²
这已经超出 int 上限(约 2.1 × 10⁹)
所以必须用 long long
用 long long
⚠️关于"原地不动"的实现:最自然的写法是 if (s > 1) s /= 2;。如果写成 s /= 2 不加判断,s = 1 时结果还是 1(因为 1/2 = 0 在整除下……)注意:C++ 里 1 / 2 = 0,所以不加判断会得到 0 而不是 1!
这是本题最常见的失分点。
🟢 逐指令模拟(推荐) 推荐
按 U/L/R 依次更新 s,注意根边界
时间 O(n)
n = 10⁶ 时约 10⁶ 次
代码 15 行
直观、不易错
💡三个更新式:U 且 s > 1 → s /= 2;L → s = 2s;R → s = 2s + 1。全部用 long long。
🟠 用二进制路径直接算
把编号转成二进制路径,直接对路径做增删操作
思路巧妙但对本题没必要
边界处理更麻烦
本题 n 只有 10⁶,模拟足够快
适合做"理解方式"
⚠️什么时候值得用二进制视角:如果 n 极大(如 10¹⁸)而需要快速跳跃,二进制/位运算会更高效。本题只需要"理解"这个视角,代码还是模拟最稳。
📈 性能对比
方案复杂度代码量
逐指令模拟O(n)约 15 行
二进制路径法O(n)(同级)约 30 行
第一行输入 n 和 s,第二行输入指令串,程序会逐步模拟并展示路径。
输入数据3 2
URR
算一下!
随机出题
结果会显示在这里
点按钮开始 →
include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long s; // 必须用 long long!
scanf("%d %lld", &n, &s);
string mv;
cin >> mv;
for (int i = 0; i < n; i++) {
if (mv[i] == 'U') {
if (s > 1) s /= 2; // 在根(s == 1)时原地不动
} else if (mv[i] == 'L') {
s = 2 * s; // 左儿子
} else { // 'R'
s = 2 * s + 1; // 右儿子
}
}
printf("%lld\n", s);
return 0;
}
🔑为什么 U 一定要加 if (s > 1)?因为 C++ 的整数除法是"向零取整",1 / 2 = 0。如果不加判断,在根结点执行 U 会让编号变成 0,而 0 不是合法的结点编号,后续所有操作都会出错。
这个"根结点"的边界是本题唯一的坑,也是"读题要读全"(题目明确写了"否则不移动")的典型例子。
📖 关键几行怎么看
代码作用为什么这样写
long long s类型s 可达 10¹²,2s+1 可达 2 × 10¹²
if (s > 1) s /= 2;U 操作根结点原地不动
s = 2 * s;L 操作左儿子编号
s = 2 * s + 1;R 操作右儿子编号
cin >> mv读指令串不含空格,直接读入
⚠️四个坑:① 用 int(s 可达 10¹²,会溢出);② U 操作没有判断根结点(会导致编号变 0);③ 把 L、R 的公式写反;④ 用 scanf("%s") 时忘记开足够大的字符数组。
写完程序后,用这些数据自查一遍:
输入答案考察点
3 2
URR7题面样例(2 → 1 → 3 → 7)
1 1
U1在根执行 U,原地不动
3 4
UUU14 → 2 → 1 → 1
2 1
LR51 → 左儿子 2 → 右儿子 5
3 1
LLL8一路向左:1 → 2 → 4 → 8
1 1000000000000
U500000000000大编号处理,验证 long long
✅自查清单:① 用 long long 吗?② U 判根了吗?③ L、R 公式对吗?
🚨 易错点清单
⚠️用 int:s 可达 10¹²,2s+1 更是超出 int,必须 long long。
⚠️U 没判根:1/2 = 0,会导致编号变成 0。
⚠️公式写反:左儿子 2s、右儿子 2s+1。
时间复杂度
O(n)
空间复杂度
O(n)
n 最大
10⁶
运算量
约 10⁶
时间怎么算的?
逐条指令处理,每条 O(1)
合计 O(n)
若用字符数组读入,空间 O(n)
空间都用在哪?
需要存下 n 个字符的指令串。
✅ 约 100 万次操作,瞬间完成。本题属于"考细心"的模拟题,难点全在边界和类型上。
// 完全二叉树(堆式)编号的父子关系
// 父结点: i / 2
// 左儿子: 2 * i
// 右儿子: 2 * i + 1
// 是否为左儿子: i 为偶数
// 是否为右儿子: i 为奇数(且 i > 1)
// 层号(从 0 开始): floor(log2(i))
// 编号 → 路径(二进制视角)
// 把 i 写成二进制,去掉最高位的 1,
// 剩下的每一位:0 表示"向左",1 表示"向右"
// 例如 13 = 1101 -> 去掉首位得 101 -> 右、左、右
// 求 LCA(最小公共祖先)的简单写法(利用编号性质)
while (a != b) {
if (a > b) a /= 2;
else b /= 2;
}
// 求两点距离
int dist(int a, int b) {
int d = 0;
while (a != b) {
if (a > b) a /= 2; else b /= 2;
d++;
}
return d;
}
🌟 举一反三
把这道题用到的基本功拆出来,它们能迁移到很多同类问题上。
能力点本题怎么用还能迁移到
堆式编号父子关系 O(1) 计算完全二叉树、堆、线段树
二进制即路径编号与路径一一对应快速心算结点位置
同时上跳求 LCA深者先跳完全二叉树上的 LCA 与距离
🌟思考题:如果指令串里出现了连续很多个 U(比如 10⁶ 个 U 而 s 很小),有没有办法加速?(提示:可以用位运算——先把 s 的位数算出来,多余的 U 直接跳过(因为在根不动)。不过本题 n 只有 10⁶,直接模拟完全够快,不必过度优化。)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long s; // 必须用 long long!
scanf("%d %lld", &n, &s);
string mv;
cin >> mv;
for (int i = 0; i < n; i++) {
if (mv[i] == 'U') {
if (s > 1) s /= 2; // 在根(s == 1)时原地不动
} else if (mv[i] == 'L') {
s = 2 * s; // 左儿子
} else { // 'R'
s = 2 * s + 1; // 右儿子
}
}
printf("%lld\n", s);
return 0;
}// 完全二叉树(堆式)编号的父子关系
// 父结点: i / 2
// 左儿子: 2 * i
// 右儿子: 2 * i + 1
// 是否为左儿子: i 为偶数
// 是否为右儿子: i 为奇数(且 i > 1)
// 层号(从 0 开始): floor(log2(i))
// 编号 → 路径(二进制视角)
// 把 i 写成二进制,去掉最高位的 1,
// 剩下的每一位:0 表示"向左",1 表示"向右"
// 例如 13 = 1101 -> 去掉首位得 101 -> 右、左、右
// 求 LCA(最小公共祖先)的简单写法(利用编号性质)
while (a != b) {
if (a > b) a /= 2;
else b /= 2;
}
// 求两点距离
int dist(int a, int b) {
int d = 0;
while (a != b) {
if (a > b) a /= 2; else b /= 2;
d++;
}
return d;
}②编程打卡 · 点一下就能勾选
- 完成 P11375《树上游走》,跑通全部样例
- 对比题解里的参考代码,找出自己写法的差异
六级模拟自测卷
- 1.B 第 k 层最多 2^(k-1) 个,2³ = 8
- 2.A 如 n=7 → ⌊2.8⌋+1 = 3 层
- 3.A 前序定根、中序分左右;「前序+后序」才无法唯一确定
- 4.B 左孩子 2i、右孩子 2i+1、父结点 ⌊i/2⌋
- 5.B 任一编码都不是另一编码的前缀,可唯一解码
- 6.B DFS 递归或显式栈;BFS 用队列保证按层扩展
- 7.B 倒序保证 dp[j] 用的是「上一轮」的值,即每件物品只用一次
- 8.B 构造函数无返回类型(连 void 都不写),可以重载
- 9.B 函数重载是编译期静态绑定;virtual 才在运行时按对象真实类型调用
- 10.B LIFO
- 11.A front == rear 判空;(rear+1)%MAX == front 判满
- 12.B 左 < 根 < 右,中序即升序
- 13.A 后序的最后一个元素是根
- 14.B 完全二叉树只要求最后一层靠左连续,不要求每层填满
- 15.A 这是它能用于压缩的前提
- 16.B 静态成员属于类、没有 this,无法动态绑定
- 17.B private 成员派生类不可见,需用 protected
- 18.B 反例很多,必须用动态规划
- 19.A 按层扩展保证步数最少
- 20.A 树是无环连通图