我们来逐步分析这个问题，并给出正确的
C++ 解法。
---
### ✅ 问题解析
题目大意：
- 有 `m` 道判断题，每道题的答案是 `'Y'` 或 `'N'`。
- 有 `n` 个“
神犇”给出了他们的答案（每人一个长度为 `m` 的字符串，由 `'Y'` 和 `'N'` 组成）。
- 已知这 `n` 个人中：
- 有 `p` 个人得了 **满分**（即所有题都答对）；
- 有 `q` 个人得了 **零分**（即所有题都答错）；
- 其余的人既不是满分也不是零分。
- 我们要根据这些信息，**还原出唯一的标准答案**（即每道题的正确答案）。
- 如果有多个可能的标准答案，输出**字典序最小的**。
- 如果无解，输出 `-1`。
---
### 🔍 解题思路
#### 关键观察：
假设某个
神犇的答案为 `ans[i]`，如果我们假设标准答案是 `res`，那么这个
神犇的得分就是：
> `score = 与 res 相同的位置数`
- 若该
神犇是满分，则 `score == m`
- 若该
神犇是零分，则 `score == 0`
- 否则 `0 < score < m`
我们的目标是找出一个候选答案 `res`（长度为 `m`），使得可以从中选出：
- 恰好 `p` 个
神犇，其答案与 `res` 完全相同（满分）
- 恰好 `q` 个
神犇，其答案与 `res` 完全相反（零分，即每一位都不一样）
- 剩下的 `n - p - q` 个人既不完全相同也不完全相反
并且我们要在所有合法的 `res` 中选择**字典序最小的**。
---
### 🚀 算法设计
由于 `m <= 500`，但 `n <= 30000`，不能枚举所有 $2^m$ 种答案。
但是注意：**标准答案必须和至少 p 个
神犇完全一致，且和至少 q 个
神犇完全相反。**
因此我们可以考虑：**枚举每一个
神犇的答案作为候选标准答案，或其取反作为候选标准答案**。
为什么？
因为如果某个
神犇是满分，那他的答案就是标准答案；如果是零分，那他的答案取反就是标准答案。
所以，真正的标准答案一定出现在以下集合中：
> `{ ans[i], reverse(ans[i]) }` 对于所有 i ∈ [0, n)
其中 `reverse(s)` 表示将 `'Y'` 变 `'N'`，`'N'` 变 `'Y'`
这样最多只有 `2n` 个候选答案，而 `n <= 30000`，但我们只需要检查最多 `60000` 个候选？——不行，太多了。
但注意：我们只关心那些有可能成为标准答案的串。而且我们最终要的是字典序最小的合法答案。
优化思路：
我们可以遍历所有 `n` 个原始答案及其取反，生成最多 `2n` 个候选答案，然后去重后排序（按字典序），再逐个验证是否满足条件。
但由于 `n=30000`，最多 `60000` 个候选串，每个串长 `500`，总时间复杂度约为 `60000 * 30000 = 1.8e9`，可能会超时。
需要更高效的方法。
---
### ✅ 更优策略
换一种角度思考：
设我们猜测某个字符串 `res` 是标准答案。
对于每个
神犇 `i` 的答案串 `s[i]`，我们可以计算它与 `res` 的匹配数：
```cpp
int cnt = 0;
for (j=0; j<m; j++) if (s[i][j] == res[j]) cnt++;
```
- 若 `cnt == m` → 该人满分
- 若 `cnt == 0` → 该人零分
- 否则 → 中间分
我们希望：能在 `n` 个人中选出恰好 `p` 个满分、`q` 个零分。
但注意：题目并没有说哪 `p` 个是满分、哪 `q` 个是零分，只要存在一种分配方式即可。
所以我们不需要知道是谁，只需要统计：
- 有多少人的答案等于 `res` → 记作 full_count
- 有多少人的答案等于 `not(res)` → 记作 zero_count
- 其他人数为 rest_count
其中 `not(res)` 是指每一位都相反的字符串。
那么必须满足：
```cpp
full_count >= p
zero_count >= q
且 (n - full_count - zero_count) >= (n - p - q) // 即剩下的人足够填充非满非零部分
→ 实际上等价于 full_count >= p && zero_count >= q
```
因为总共需要选 `p` 个满分（只能从 `full_count` 中选），`q` 个零分（只能从 `zero_count` 中选），剩下的随便填。
所以只要 `full_count >= p` 且 `zero_count >= q`，就可以选出这样的组合。
于是算法如下：
---
### ✅ 算法步骤
1. 输入 `n, m, p, q` 和 `n` 个字符串 `s[0..n-1]`
2. 收集所有候选答案：
- 所有 `s[i]` （可能是标准答案，若第 i 个是满分）
- 所有 `flip(s[i])`（可能是标准答案，若第 i 个是零分）
3. 将这些候选加入集合，然后去重并按字典序排序
4. 遍历每个候选 `res`（从小到大），尝试验证是否合法
5. 验证方法：
- 统计有多少个 `s[i] == res` → full_match
- 统计有多少个 `s[i] == flip(res)` → zero_match
- 若 `full_match >= p && zero_match >= q`，则 `res` 是合法答案
6. 输出第一个合法的 `res`
7. 若没有合法的，输出 `-1`
---
### 💡 注意事项
- 字符串比较可以直接用 `std::string` 的 `==`
- `flip(s)` 函数：把 `'Y'` 变 `'N'`，`'N'` 变 `'Y'`
- 使用 `set<string>` 自动去重+排序，然后转为 vector 并排序（其实 set 已经有序）
但注意：`set` 是红黑树，默认升序，正好是字典序。
---
### ✅
C++ 代码实现
```cpp
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <string>
using namespace std;
string flip(const string& s) {
string t = s;
for (char& c : t) {
c = (c == 'Y') ? 'N' : 'Y';
}
return t;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, p, q;
cin >> n >> m >> p >> q;
vector<string> answers(n);
for (int i = 0; i < n; ++i) {
cin >> answers[i];
}
// 构建候选答案集合（去重 + 排序）
set<string> candidateSet;
for (int i = 0; i < n; ++i) {
candidateSet.insert(answers[i]);
candidateSet.insert(flip(answers[i]));
}
// 转为有序列表（已经是有序的）
vector<string> candidates(candidateSet.begin(), candidateSet.end());
sort(candidates.begin(), candidates.end()); // 实际上 set 已排序
// 预先计算每个答案的翻转，避免重复计算
vector<string> flipped(n);
for (int i = 0; i < n; ++i) {
flipped[i] = flip(answers[i]);
}
// 遍历每个候选答案
for (const string& res : candidates) {
int full_match = 0; // 答案完全相同的数量（满分者）
int zero_match = 0; // 答案完全相反的数量（零分者）
for (int i = 0; i < n; ++i) {
if (answers[i] == res) {
full_match++;
}
if (flipped[i] == res) { // 即 answers[i] 与 res 完全不同
zero_match++;
}
}
if (full_match >= p && zero_match >= q) {
cout << res << '\n';
return 0;
}
}
// 无解
cout << "-1\n";
return 0;
}
```
---
### ⚠️ 复杂度分析
- 候选答案数：最多 `2n = 60000`
- 每个候选验证需遍历 `n=30000` 个字符串，每次比较 `m=500` 字符 → 最坏 `60000 * 30000 = 1.8e9` 次操作，可能超时！
我们需要优化！
---
### ✅ 优化方案：减少候选数量
关键观察：真正有意义的候选答案只有那些能作为“某人满分或零分”的答案。
但更重要的是：**标准答案必须使得至少 p 个人与其相同，q 个人与其相反。**
我们可以反过来：只枚举 `answers[i]` 和 `flip(answers[i])`，但不去重太多也没关系，最多 `2n`。
然而最坏情况仍然不可接受。
进一步优化：
我们可以先预处理两个映射：
- `countOrig[s]`: 原始答案为 s 的人数
- `countFlip[s]`: 翻转后为 s 的人数（即原串为 flip(s) 的数量）
但更好的做法是：
枚举所有 `i`，把 `answers[i]` 和 `flip(answers[i])` 加入候选集，然后对候选集去重排序。
然后对每个候选 `res`，我们快速统计：
- `full_match = countOrig[res]`
- `zero_match = countOrig[flip(res)]` → 因为若某人原始答案是 `t`，且 `t == flip(res)`，则 `res == flip(t)`，说明此人全错
所以我们可预先用 `map<string, int>` 统计每个原始字符串出现次数。
---
### ✅ 优化后的代码（推荐）
```cpp
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
using namespace std;
string flip(const string& s) {
string t = s;
for (char& c : t) {
c = (c == 'Y') ? 'N' : 'Y';
}
return t;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, p, q;
cin >> n >> m >> q >> q; // 注意：这里 p 和 q 都要用
cin >> n >> m >> p >> q;
vector<string> answers(n);
map<string, int> freq;
for (int i = 0; i < n; ++i) {
cin >> answers[i];
freq[answers[i]]++;
}
set<string> candidateSet;
for (int i = 0; i < n; ++i) {
candidateSet.insert(answers[i]);
candidateSet.insert(flip(answers[i]));
}
vector<string> candidates(candidateSet.begin(), candidateSet.end());
sort(candidates.begin(), candidates.end());
for (const string& res : candidates) {
int full_match = freq[res]; // 多少人答成 res（满分）
int zero_match = freq[flip(res)]; // 多少人答成 flip(res)，翻转后等于 res → 零分
if (full_match >= p && zero_match >= q) {
cout << res << '\n';
return 0;
}
}
cout << "-1\n";
return 0;
}
```
等等！上面有个 bug：我写了两遍 `cin >> ...`，修正一下。
---
### ✅ 最终正确代码
```cpp
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <string>
using namespace std;
string flip(const string& s) {
string t = s;
for (char& c : t) {
c = (c == 'Y') ? 'N' : 'Y';
}
return t;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, p, q;
cin >> n >> m >> p >> q;
vector<string> answers(n);
map<string, int> freq;
for (int i = 0; i < n; ++i) {
cin >> answers[i];
freq[answers[i]]++;
}
set<string> candidateSet;
for (int i = 0; i < n; ++i) {
candidateSet.insert(answers[i]);
candidateSet.insert(flip(answers[i]));
}
for (const string& res : candidateSet) {
int full_match = freq[res];
int zero_match = freq[flip(res)];
if (full_match >= p && zero_match >= q) {
cout << res << '\n';
return 0;
}
}
cout << "-1\n";
return 0;
}
```
> 注意：`candidateSet` 是 `set`，自动按字典序排序，因此我们按顺序遍历时，第一个合法的就是字典序最小的。
---
### ✅ 正确性保证
- 枚举了所有可能的标准答案（来自满分者或零分者的答案）
- 使用哈希表 `freq` 快速统计频次
- 时间复杂度：O(2n × m) 用于构造 flip 和插入 set，O(2n × n_log?) 实际上是 O(n log n) 排序/插入，总体可接受
---
### ❧ 总结
本题核心在于：
- 标准答案必然等于某个
神犇的答案（若是满分）或其反串（若是零分）
- 因此只需枚举这些候选
- 利用哈希表加速统计匹配人数
- 输出第一个满足 `full >= p && zero >= q` 的候选
---
本文精选了三位编程高手的个人博客，这些博客不仅提供了高质量的题目和题解，而且页面简洁、代码风格优良，适合（准）程序员阅读。博主们还会不定期分享C++黑科技等内容。
扫一扫
154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
