我们来分析这个题目并提供一个 **
C++14** 的解决方案。
---
### 🧠 **
问题理解**
- 初始：多重集合为空，得分为 0。
- 操作：
- **插入**：可以插入 `2` 或 `4`，前提是集合大小 `< k`。
- **合并**：如果有两个 `x`，可以移除它们，加入一个 `2x`，并获得得分 `2x`。
- 目标：对每个目标分数 $ h_i $，找出游戏结束时可能的多重集合（任意一个），或输出 `-1` 表示无法达到。
---
### 🔍 **关键观察**
#### 1. 所有数都是 2 的幂
因为：
- 插入的数是 `2` 或 `4`（即 $2^1$, $2^2$）。
- 合并 $x + x \to 2x$，所以结果仍是 $2$ 的幂。
因此，任何时候集合中所有元素都是形如 $2^a$ 的整数。
我们可以用指数表示：比如把 `2` 记为 `1`，`4` → `2`，`8` → `3`，等等。
#### 2. 合并操作等价于二进制进位
考虑从最小的数开始合并：
- 每次合并两个 $2^a$ 得到一个 $2^{a+1}$，并得分为 $2^{a+1}$。
- 这类似于在二进制中“进位”：两个低位变成一个高位。
但注意：**得分是每次合并时加上的 $2x = 2 \cdot 2^a = 2^{a+1}$**。
所以，如果我们最终得到了某个数 $2^m$，它是由若干底层的 `2` 和 `4` 合并而来，那么它的“贡献得分”是可以计算的。
#### 3. 总得分等于所有合并操作中产生的 $2x$
我们可以反向思考：给定一个最终的多重集合，能否通过一
系列合并和插入得到，并且总得分恰好是 $h_i$？
或者更聪明地：**是否可以将 $h_i$ 分解成一些合并得分之和？**
---
### ✅ **核心思路：贪心模拟 + 反向构造**
我们可以尝试从目标分数出发，反向模拟“拆分”过程。但更有效的是正向构造：
> 我们知道，任何得分都来自合并操作，而合并操作只能产生 $2x$，其中 $x$ 是某个 $2^a$。
更重要的是：**每一次合并操作都消耗两个相同的数，生成一个更大的数，并增加得分 $2x$**。
我们可以考虑：**最终状态的多重集合决定了整个合并历史的可能性**。
---
### 💡 关键洞察：最大可得分为完全合并链
假设我们只插入 `2`，然后尽可能合并：
- 插入两个 `2` → 合并成 `4`，得分 += 4
- 再两个 `2` → 合并成 `4`
- 两个 `4` → 合并成 `8`，得分 += 8
- ...
- 最终可能得到一个
大数，比如 $2^m$
但受限于最多 $k$ 个元素，不能无限保留中间值。
然而，有一个重要结论：
> **对于固定的最终多重集合 $S$，其对应的最大可能得分是唯一确定的（如果一直合并下去），但 Hermione 可以选择何时停止合并。**
但我们的
问题是反过来的：给定得分 $h$，找一个合法的最终集合。
---
### ✅ 正确做法：枚举所有可能的最终集合（状态压缩）
由于 $k \leq 16$，而且所有数都是 $2^a$，我们可以用 **指数形式** 来表示每个数。
令我们维护一个向量 $c[a]$ 表示当前有多少个 $2^a$。
初始全为 0。
每次插入：增加一个 $2^1$ 或 $2^2$（即 $a=1$ 或 $a=2$）。
合并：两个 $c[a]$ 减少，一个 $c[a+1]$ 增加，得分增加 $2^{a+1}$。
最终状态是一个向量 $c[]$，满足 $\sum c[a] \le k$。
我们可以预处理出所有可以通过合法操作序列达到的 (最终集合, 总得分) 对。
但由于 $h_i$ 最大到 $10^9$，不能直接 DP 所有得分。
---
### ⚙️ 更高效的思路：逆推 + 贪心分解
#### 观察：**所有得分都是若干个 $2^b$ 的和（$b \geq 2$）**
因为每次合并得分为 $2x = 2^{a+1} \geq 4$（当 $x=2$ 时得 4）
所以：**所有得分 $h_i$ 必须是若干个 $\geq 4$ 的 $2$ 的幂的和？不对！**
等一下：不是这样，因为同一个 $2^b$ 可以多次出现。
实际上，得分就是所有合并事件中产生的 $2x$ 值的总和。
---
### ✅ 突破口：考虑最终集合与原始插入之间的关系
设我们总共插入了 $t_2$ 个 `2` 和 $t_4$ 个 `4`。
那么总共有 $t = t_2 + t_4$ 次插入。
这些数经过一
系列合并，最终形成当前集合中的数。
每个合并操作减少一个元素（两个变一个），所以总共进行了 $t - s$ 次合并（$s$ 是最终大小）。
每次合并产生得分 $2x$，总得分为 $h$。
但更重要的是：**每个最终的数 $v = 2^a$ 是由若干底层的数合并而成，其“能量”可以用其来源的合并得分贡献来衡量。**
---
### 🔑 经典类比：**2048 游戏得分模型**
这类似于 2048 游戏：合并两个 $x$ 得到 $2x$，得分加 $2x$。
在这种游戏中，生成一个数 $2^m$ 所需的最小合并得分是固定的。
例如：
- 生成 `4`（即 $2^2$）有两种方式：
- 插入 `4`：不需要合并，得分不增加（但它本身不是由合并来的）
- 合并两个 `2`：得分 += 4
但注意：**只有合并才加分**。
所以我们需要区分：哪些数是由合并产生的，哪些是直接插入的。
---
### ✅ 正确方法：使用 BFS/DFS 枚举所有可达的 (multiset, score) 状态
由于 $k \leq 16$，且所有数是 $2^a$，而 $2^a$ 不会太大（因为 $h \leq 10^9$，最多到 $2^{30}$ 左右），但实际中由于 $k$ 小，不可能有太大的数。
我们可以做如下事情：
> 预处理：对每个可能的最终多重集合（用计数数组表示），计算它能对应的 **最大可能得分**（即继续合并直到不能再合并）以及 **所有可达得分路径**。
但这太复杂。
---
### ✅ 实用策略：**从空集开始 BFS，生成所有在 $k$ 限制下可达的状态及其得分**
状态表示：
- 多重集合：我们用一个排序后的元组表示，元素都是 $2^a$，长度 ≤ k。
- 得分：整数。
但我们不能存所有得分（太大），但我们只需要回答 $n \leq 10^4$ 个查询。
所以我们可以预先生成所有在 $k$ 限制下、通过合法操作可达的 **(最终集合, 得分)** 对，其中“最终集合”是指玩家选择停止时的状态（不一定不能再合并）。
但玩家可以在任何时刻停止，所以只要存在一条路径到达某个集合 $S$ 且得分为 $h$，就可以输出 $S$。
---
### ✅ 因此
算法如下：
使用 **BFS 或 DFS** 枚举所有可达状态：
- 状态：`(multiset, score)`，其中 multiset 是一个有序元组（方便哈希），元素为整数（必须是 2 的幂），大小 ≤ k。
- 初始状态：`({}, 0)`
- 操作：
1. 插入 `2`：若 size < k，则添加 `2`
2. 插入 `4`：若 size < k，则添加 `4`
3. 合并：对每个 `x` 出现 ≥2 次的数，可以合并两个 `x` → 添加 `2*x`，得分 += `2*x`
我们记录：对于每个得分 $h$，保存一个能达到它的最终集合（任意一个）。
由于 $k \leq 16$，且数字是 $2^a$，我们可以限制 $a \leq 60$（足够），但实际上由于得分上限 $10^9$，最
大数不会超过 $2^{30}$。
但状态空间仍然很大？不过由于 $k$ 很小，且每次插入最多 $k$ 次，合并次数也有限，我们可以剪枝：
- 使用 `visited[state]`：但 state 包含集合和得分？得分太大。
但我们关心的是：对于每个得分 $h$，有没有办法达到它？
我们可以做一个映射：`map<long long, vector<int>> answer`：得分 → 达到该得分时的一个合法最终集合。
然后 BFS 所有可能状态。
---
### ✅ 优化：使用规范形式表示集合
我们将多重集合表示为排序后的 `vector<int>`，便于哈希。
但由于状态太多，我们需要剪枝：
- 如果两个状态具有相同的集合和相同的得分，只需访问一次。
- 但如果集合相同但得分不同，是不同状态。
但更糟的是：相同集合可以通过不同路径得到不同得分？不可能！
⚠️ 注意：**得分是合并操作累计的，所以相同的操作序列得到相同的得分。但是不同的操作顺序可能导致相同的最终集合但不同得分吗？**
❌ 不可能。因为每一步操作是确定性的，得分是累加的。
但更重要的是：**同一个集合可能通过不同路径达到，得分也可能不同！**
例如：
- 先插入 `2`,`2` → 合并得 `4`（得分=4）
- 再插入 `4` → 集合={4,4}
vs
- 先插入 `4`, `4` → 集合={4,4}，得分=0
→ 相同集合，不同得分！
所以：**(集合, 得分)** 是状态的一部分。
但我们无法存储所有 `(集合, 得分)` 对，因为得分可达 $10^9$。
---
### ✅ 替代方案：对每个查询 $h_i$ 单独搜索（DFS/BFS with pruning）
但 $n \leq 10^4$，不能对每个都搜。
---
### ✅ 成功思路：**动态规划 + 状态去重（按集合）**
我们意识到：**对于同一个集合，我们只关心是否能在某个得分 $h$ 下达到它。但我们想要的是：对于给定的 $h$，是否存在一条路径使得最终得分为 $h$ 且最终集合为 $S$。**
但我们不需要所有 $h$，只需要回答 $n$ 个查询。
所以我们可以：
> 从初始状态开始 BFS，生成所有在合理步数内可达的 `(集合, 得分)` 对，并记录 `ans[h] = S`
但得分可能非常大。
---
### ✅ 现实可行方案：利用 $k$ 很小 + 数字是 2 的幂 + 合并树结构
#### 关键洞察：**任何最终集合 $S$ 对应一组“未合并”的块，而得分 $h$ 是合并过程中产生的所有 $2x$ 之和**
我们可以考虑：**总得分 $h$ 必须等于所有合并操作的产出之和**
而每个合并操作本质上是“消耗两个 $x$，产出一个 $2x$”，得分加 $2x$
这类似于构建一棵二叉树：叶子是插入的 `2` 或 `4`，内部节点是合并操作，值为 $2x$，得分加上该值。
所以，**总得分 = 所有内部节点的值之和**
而最终集合 = 根节点们的值（未被进一步合并的）
于是
问题变为：
> 是否存在一组叶子（全是 `2` 或 `4`），通过合并形成一组根节点（即最终集合），使得内部节点值之和为 $h$，且任意时刻节点数 ≤ $k$？
这个
问题很难直接解。
---
### ✅ 实践成功的方法：**暴力 BFS，限制数值范围**
我们进行 BFS，状态为：
```cpp
state = {
multiset
: vector<int> (sorted),
score
: int (long long)
}
```
我们使用 `set<pair<vector<int>, long long>> visited` 来避免重复状态。
但由于得分大，我们改为：`map<vector<int>, set<long long>> visited`：记录每个集合达到过的得分。
同时，我们维护一个全局 `map<long long, vector<int>> reachable`：得分 → 一个能达到它的集合。
#### 剪枝策略：
- 数值不要太大：如果某个数 > $2^{50}$，跳过（实际上 $h \leq 10^9$，最大合并值约 $2^{30}$）
- 集合大小 ≤ k
- 插入的数只能是 2 或 4
- 合并操作：对每个出现 ≥2 次的 x，执行合并
我们从空集开始 BFS。
---
### ✅
C++14 实现
```cpp
#include <bits/std
c++.h>
using namespace std;
typedef long long ll;
using State = vector<int>; // sorted multiset of powers of 2
// Global mapping
: score -> one possible final state
map<ll, State> ansForScore;
// Avoid repeated states
: state -> set of scores that reached it
map<State, set<ll>> visited;
int k_max;
// Normalize and check size
bool addState(const State& s, ll score) {
if (s.size() > k_max) return false;
// Check if this (s, score) has been seen
if (visited[s].count(score)) return false;
visited[s].insert(score);
// Only record first time we reach this score
if (ansForScore.find(score) == ansForScore.end()) {
ansForScore[score] = s;
}
return true;
}
void bfs() {
queue<pair<State, ll>> q;
State start = {};
q.push({start, 0});
addState(start, 0);
while (!q.empty()) {
auto [state, score] = q.front(); q.pop();
// Operation 1
: Insert 2
if (state.size() < k_max) {
State nxt = state;
nxt.push_back(2);
sort(nxt.begin(), nxt.end());
if (addState(nxt, score)) {
q.push({nxt, score});
}
}
// Operation 2
: Insert 4
if (state.size() < k_max) {
State nxt = state;
nxt.push_back(4);
sort(nxt.begin(), nxt.end());
if (addState(nxt, score)) {
q.push({nxt, score});
}
}
// Operation 3
: Merge two x into 2x
map<int, int> cnt;
for (int x
: state) cnt[x]++;
for (auto [x, c]
: cnt) {
if (c >= 2) {
State nxt;
for (int y
: state) {
if (y == x) continue;
nxt.push_back(y);
}
// remove two x
// add one 2*x
nxt.push_back(2 * x);
sort(nxt.begin(), nxt.end());
ll new_score = score + 2 * x;
if (new_score > 1000000000LL) continue; // h_i <= 1e9
if (addState(nxt, new_score)) {
q.push({nxt, new_score});
}
}
}
}
}
int main() {
// Read input
int n;
cin >> n >> k_max;
vector<ll> queries(n);
for (int i = 0; i < n; i++) {
cin >> queries[i];
}
// Precompute all reachable scores and states
bfs();
// Output answers
for (ll h
: queries) {
if (ansForScore.count(h)) {
State res = ansForScore[h];
cout << res.size();
for (int x
: res) {
cout << " " << x;
}
cout << "\n";
} else {
cout << "-1\n";
}
}
return 0;
}
```
---
### ✅ 解释
- 我们使用 BFS 枚举所有可能的 `(多重集合, 得分)` 状态。
- 每个状态可以执行三种操作：插入 `2`、插入 `4`、合并两个相同的数。
- 使用 `map<State, set<ll>> visited` 防止重复搜索。
- 使用 `ansForScore` 记录每个得分首次达到时的集合。
- 输出时直接查表。
---
### ⚠️ 注意事项
- 由于 $k \leq 16$，状态数量有限（虽然指数增长，但合并会使数变大，从而限制深度）。
- 得分上限为 $10^9$，我们剪枝掉超过此值的得分。
- 数值增长快，BFS 实际上不会爆炸。
---
### 📌 测试样例验证
#### 输入 #1
:
```
1 2
12
```
可能路径：
- 插入 2 → {2}
- 插入 2 → {2,2}
- 合并 2 → {4}, 得分 +=4
- 插入 4 → {4,4}
- 合并 4 → {8}, 得分 +=8 → 总得分 12
最终集合：{8} → 输出 `1 8` ✅
#### 输入 #2
:
```
4 5
4
12
10
20
```
- `4`
: 可能是合并两个 `2` 得到 `{4}`，得分=4 → 输出 `1 4`？但样例输出是 `2 4 2`
- 说明：玩家可以在合并后继续插入，然后停止！
- 例如：插入 `2`,`2` → 合并 → `{4}`, 得分=4；再插入 `2` → `{4,2}` → 停止
- 所以输出 `2 4 2` 是合法的，尽管还能合并。
→ 我们的 BFS 允许在任意中间状态停止，因此会记录所有中间状态。
所以我们的程序会找到这些非完全合并的状态。
样例输出：
```
2 4 2
5 8 4 2 2 4
-1
3 2 4 8
```
我们的程序可能输出不同顺序，但元素相同即可（输出顺序任意）。
---
### ❌ 为什么有些分数无法达到？
比如 `10`：能否得到得分 10？
- 合并得分只能是 4, 8, 16, 32, ...
- 10 = 8 + 2？但没有得分为 2 的操作
- 可能组合：4+4+2？不行
- 10 无法表示为若干个 $2^b$（$b\geq2$）的和？
- 10 = 8 + 2 ❌（2<4）
- 10 = 4+4+2 ❌
- 10 = 4+6 ❌
- 实际上：10 无法由若干个 ≥4 的 2 的幂相加得到？错！4+4+2 不行，但 4+6 不行。
等等：合并得分是 $2x$，x 是合并的数，所以必须是 4, 8, 16,...
所以得分是若干个 $2^b$（$b \geq 2$）的和。
10 = 8 + 2 ❌（2 不合法）
10 = 4 + 6 ❌
10 = 4 + 4 + 2 ❌
→ 无法表示为若干个 ≥4 的 2 的幂的和？
但 4+4=8，不够；4+4+4=12>10
所以 10 无法达到 → 输出 -1 ✅
---
### ✅ 结论
上述代码应该能正确处理所有情况。
---
博客围绕求无序正整数序列中第k大的数展开。给定长度为n的无序正整数序列和数k，说明了输入格式为第一行两个正整数m、n，第二行为n个正整数，输出为第k大的数，还给出了样例输入和输出。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
