题目描述
教授 X 要给 NNN 个学生分组完成学期任务,他希望每个小组恰好有 KKK 个学生。 当无法让所有小组都恰好有 KKK 个学生时,最多可以有一个小组的学生数少于 KKK 。 学生用前 NNN 个大写英文字母表示( A 到 A + N - 1 )。
我们需要处理两种查询:
- COUNT\texttt{COUNT}COUNT NNN KKK :计算可以组成小组的方式数量
- GENERATE\texttt{GENERATE}GENERATE NNN KKK :生成所有可能的分组方式列表
分组规则
- 每个学生只能属于一个小组
- 小组内学生的不同排列顺序被视为相同(即组内无序)
- 组内学生按字母顺序排列
- 组间按字典序排列(使用
ASCII值比较) - 所有解按字典序排序
输入限制
- 最多 1200 个测试用例
- COUNT\texttt{COUNT}COUNT 查询: 1≤N,K≤301 \le N, K \le 301≤N,K≤30
- GENERATE\texttt{GENERATE}GENERATE 查询: 1≤N,K≤151 \le N, K \le 151≤N,K≤15
- 每个 GENERATE\texttt{GENERATE}GENERATE 查询的解不超过 100001000010000 行
- 所有 GENERATE\texttt{GENERATE}GENERATE 查询的总解不超过 300003000030000 行
题目分析
分组情况分析
设总人数为 NNN ,理想小组大小为 KKK ,则:
-
整除情况 :当 N mod K=0N \bmod K = 0NmodK=0 时
- 所有小组大小都为 KKK
- 小组数 g=N/Kg = N / Kg=N/K
-
非整除情况 :当 N mod K=r>0N \bmod K = r > 0NmodK=r>0 时
- 有一个小组大小为 rrr
- 其余 g−1g-1g−1 个小组大小都为 KKK
- 小组数 g=⌈N/K⌉g = \lceil N/K \rceilg=⌈N/K⌉
数学建模
这是一个 集合划分问题 ,需要考虑以下关键点:
- 组内无序 :小组内学生的排列顺序不重要
- 组间有序性 :当所有小组大小相同时,组间是无序的;当有不同大小的小组时,大小不同的小组是独特的
- 字母顺序 :组内按字母顺序排列,这简化了生成过程
计数公式推导
情况 111:整除情况( N mod K=0N \bmod K = 0NmodK=0 )
小组数 g=N/Kg = N/Kg=N/K ,所有小组大小都为 KKK 。
计算步骤:
- 将 NNN 个不同学生分配到 ggg 个小组中,每个小组大小为 KKK
- 由于组间无序,需要除以 g!g!g!
公式:
count=N!(K!)g⋅g!
\texttt{count} = \frac{N!}{(K!)^g \cdot g!}
count=(K!)g⋅g!N!
情况 222:非整除情况( N mod K=r>0N \bmod K = r > 0NmodK=r>0 )
小组数 g=⌈N/K⌉g = \lceil N/K \rceilg=⌈N/K⌉ ,有一个小组大小为 rrr ,其余 g−1g-1g−1 个小组大小为 KKK 。
计算步骤:
- 从 NNN 个学生中选择 rrr 个给较小的组: C(N,r)C(N, r)C(N,r)
- 将剩余 N−rN-rN−r 个学生分配到 g−1g-1g−1 个大小为 KKK 的组中
- 大小为 KKK 的组之间无序,需要除以 (g−1)!(g-1)!(g−1)!
公式:
count=C(N,r)⋅(N−r)!(K!)g−1⋅(g−1)!
\texttt{count} = C(N, r) \cdot \frac{(N-r)!}{(K!)^{g-1} \cdot (g-1)!}
count=C(N,r)⋅(K!)g−1⋅(g−1)!(N−r)!
大数处理
对于 COUNT\texttt{COUNT}COUNT 查询, N,K≤30N, K \le 30N,K≤30 ,最大的阶乘 30!≈2.65×103230! \approx 2.65 \times 10^{32}30!≈2.65×1032 ,这超出了 646464 位无符号整数的范围(最大值约 1.84×10191.84 \times 10^{19}1.84×1019 )。 因此需要使用 128128128 位整数 来避免溢出。
解题思路
1. COUNT\texttt{COUNT}COUNT 查询实现
使用 __int128 类型处理大数计算:
- 预计算阶乘表
factorial[0..30] - 根据 NNN 和 KKK 的关系选择公式
- 使用组合数函数计算 C(N,r)C(N, r)C(N,r)
- 使用阶乘除法计算结果
- 将
__int128转换为字符串输出
2. GENERATE\texttt{GENERATE}GENERATE 查询实现
使用 回溯法(DFS\texttt{DFS}DFS) 生成所有解:
算法步骤:
- 表示方法 :用字符串表示小组,如
ABC表示包含学生 A、B、C 的小组 - 状态表示 :
currentGroups:当前已形成的小组列表used:标记哪些学生已被分配currentGroupSize:当前小组的当前大小currentGroupStart:当前小组的下一个学生起始索引(保证组内字母顺序)
- 递归过程 :
- 如果所有学生都已分配(
idx == N),检查是否满足小组大小约束(最多一个小组小于 KKK),如果满足则保存解 - 否则:
- 尝试将当前学生加入现有小组(如果小组未满)
- 尝试开始一个新小组
- 如果所有学生都已分配(
- 排序规则 :
- 组内:按字母顺序(通过
currentGroupStart参数保证) - 组间:按字符串字典序
- 所有解:按组序列的字典序排序
- 组内:按字母顺序(通过
剪枝优化:
- 通过
currentGroupStart参数避免生成组内无序的重复解 - 只在必要时开始新小组
- 及时检查小组大小约束
时间复杂度分析
COUNT\texttt{COUNT}COUNT 查询
- 预计算阶乘: O(30)O(30)O(30)
- 每次查询: O(1)O(1)O(1)
GENERATE\texttt{GENERATE}GENERATE 查询
- 最坏情况: N=15,K=1N=15, K=1N=15,K=1 ,解数为 15!=130767436800015! = 130767436800015!=1307674368000 ,但题目保证不超过 10000 个解
- 实际运行:由于 N≤15N \le 15N≤15 且解数有限,回溯法可以接受
代码实现
// n Group k
// UVa ID: 10568
// Verdict: Accepted
// Submission Date: 2025-12-14
// UVa Run Time: 0.320s
//
// 版权所有(C)2025,邱秋。metaphysis # yeah dot net
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using int128 = __int128;
// 预计算阶乘
vector<int128> factorial(31);
void precomputeFactorial() {
factorial[0] = 1;
for (int i = 1; i <= 30; ++i) factorial[i] = factorial[i - 1] * i;
}
// 组合数计算 C(n, k)
int128 combination(int n, int k) {
if (k < 0 || k > n) return 0;
if (k > n - k) k = n - k;
int128 result = 1;
for (int i = 1; i <= k; ++i) {
result = result * (n - k + i) / i;
}
return result;
}
// 计算分组数
int128 countWays(int n, int k) {
int groups = (n + k - 1) / k; // ceil(n/k)
int remainder = n % k;
if (remainder == 0) {
// 所有组大小都是k
int128 ways = factorial[n];
// 除以 (k!)^groups
int128 kFactorial = factorial[k];
for (int i = 0; i < groups; ++i) ways /= kFactorial;
// 除以 groups! (组间无序)
ways /= factorial[groups];
return ways;
} else {
// 有一个大小为remainder的组,其余groups-1个组大小为k
// 1. 选择remainder个学生给较小的组
int128 ways = combination(n, remainder);
// 2. 剩余学生分配到groups-1个大小为k的组中
int remaining = n - remainder;
ways *= factorial[remaining];
// 除以 (k!)^(groups-1)
int128 kFactorial = factorial[k];
for (int i = 0; i < groups - 1; ++i) ways /= kFactorial;
// 除以 (groups-1)! (大小为k的组之间无序)
ways /= factorial[groups - 1];
return ways;
}
}
// 生成所有解的数据结构
vector<vector<string>> allSolutions;
string students;
int N, K;
void generateSolutions(int idx, vector<string>& currentGroups, vector<bool>& used,
int currentGroupSize, int currentGroupStart) {
if (idx == N) {
int smallGroups = 0;
for (const auto& group : currentGroups) {
if ((int)group.size() < K) smallGroups++;
}
if (smallGroups <= 1) allSolutions.push_back(currentGroups);
return;
}
// 尝试加入当前组
if (!currentGroups.empty() && currentGroupSize < K) {
for (int i = currentGroupStart; i < N; ++i) {
if (!used[i]) {
used[i] = true;
currentGroups.back().push_back(students[i]);
generateSolutions(idx + 1, currentGroups, used, currentGroupSize + 1, i + 1);
currentGroups.back().pop_back();
used[i] = false;
}
}
}
// 开始新组
if ((int)currentGroups.size() < (N + K - 1) / K) {
for (int i = 0; i < N; ++i) {
if (!used[i]) {
used[i] = true;
currentGroups.push_back(string(1, students[i]));
generateSolutions(idx + 1, currentGroups, used, 1, i + 1);
currentGroups.pop_back();
used[i] = false;
break;
}
}
}
}
// 将int128转换为字符串
string int128ToString(int128 n) {
if (n == 0) return "0";
string result = "";
bool negative = false;
if (n < 0) {
negative = true;
n = -n;
}
while (n > 0) {
result = char('0' + (n % 10)) + result;
n /= 10;
}
if (negative) result = "-" + result;
return result;
}
int main() {
precomputeFactorial();
string query;
while (cin >> query) {
if (query == "END") break;
int n, k;
cin >> n >> k;
if (query == "COUNT") {
int128 result = countWays(n, k);
cout << int128ToString(result) << endl;
}
else if (query == "GENERATE") {
N = n;
K = k;
students = "";
for (int i = 0; i < n; ++i) students += char('A' + i);
allSolutions.clear();
vector<string> currentGroups;
vector<bool> used(n, false);
// 开始第一个组
if (n > 0) {
used[0] = true;
currentGroups.push_back(string(1, students[0]));
generateSolutions(1, currentGroups, used, 1, 1);
} else {
allSolutions.push_back({});
}
// 排序解
sort(allSolutions.begin(), allSolutions.end());
// 输出数量
cout << allSolutions.size() << endl;
// 输出具体解
for (const auto& sol : allSolutions) {
for (size_t i = 0; i < sol.size(); ++i) {
if (i > 0) cout << " ";
cout << sol[i];
}
cout << endl;
}
}
}
return 0;
}
总结
本题的核心在于:
- 数学推导 :正确推导分组计数的组合数学公式,注意区分整除和非整除情况,正确处理组间无序性
- 大数处理 :使用
__int128避免阶乘计算溢出 - 回溯生成 :使用 DFS\texttt{DFS}DFS 生成所有解,通过参数控制避免重复和保证排序规则
- 排序实现 :严格按照题目要求的三种排序规则实现
关键难点在于处理 COUNT\texttt{COUNT}COUNT 查询时的大数计算和 GENERATE\texttt{GENERATE}GENERATE 查询时的排序约束。 通过预计算阶乘、使用 __int128 类型和精心设计的回溯算法,可以高效解决这两个问题。
485



被折叠的 条评论
为什么被折叠?



