1. 问题定义与理解
首先我们需要明确题目要求：给定一个整数数组 nums 和一个整数 k，判断能否将数组中的所有元素划分成若干个大小为 k 的子集合，且满足以下两个条件：
- 每个子集合内部没有重复值
- 数组中的每个元素都必须被包含在某个子集合中
举个例子：
- 输入：nums = [1,2,3,3,4,4,5,6], k = 4
- 可能的合法分组：[[1,2,3,4], [3,4,5,6]]
- 非法分组示例：[[1,2,3,3], [4,4,5,6]]（因为第一个子集合有重复的3）
这个问题实际上是LeetCode 3659题的变种，属于数组操作和哈希表应用的经典问题。
2. 解题思路分析
2.1 基本条件检查
在开始算法设计前，我们需要先检查一些基本条件：
- 数组长度必须能被k整除，否则肯定无法分组
- 即 len(nums) % k == 0
- 任何数字的出现次数不能超过可能的子集合数量
- 即对于任意数字n，count(n) <= len(nums)/k
如果这两个基本条件不满足，可以直接返回false。
2.2 核心算法选择
这个问题可以转化为一个"分配问题"，我们需要将数字合理地分配到各个子集合中。常见的方法有：
- 贪心算法：优先处理出现次数最多的数字
- 回溯算法：尝试各种可能的分配方式
- 哈希表+排序：统计频率后按特定顺序处理
经过分析，贪心算法是最优选择，因为：
- 时间复杂度较低（O(n log n)）
- 空间复杂度为O(n)
- 能够有效处理大规模数据
3. Go语言实现详解
3.1 基本数据结构
我们需要以下数据结构：
- 频率统计map：记录每个数字出现的次数
- 排序后的唯一数字列表：按频率从高到低排序
go复制func canDivideIntoSubsets(nums []int, k int) bool {
if len(nums)%k != 0 {
return false
}
freq := make(map[int]int)
for _, num := range nums {
freq[num]++
}
// 将唯一数字按频率从高到低排序
uniqueNums := make([]int, 0, len(freq))
for num := range freq {
uniqueNums = append(uniqueNums, num)
}
sort.Slice(uniqueNums, func(i, j int) bool {
return freq[uniqueNums[i]] > freq[uniqueNums[j]]
})
// 检查是否有数字出现次数超过可能的分组数
maxGroups := len(nums) / k
for _, num := range uniqueNums {
if freq[num] > maxGroups {
return false
}
}
// 尝试构建分组
groups := make([][]int, maxGroups)
for i := range groups {
groups[i] = make([]int, 0, k)
}
// 贪心分配数字到分组
for _, num := range uniqueNums {
count := freq[num]
// 需要将num分配到count个不同的分组中
assigned := 0
for i := 0; i < len(groups) && assigned < count; i++ {
if len(groups[i]) < k && !contains(groups[i], num) {
groups[i] = append(groups[i], num)
assigned++
}
}
if assigned < count {
return false
}
}
return true
}
func contains(arr []int, num int) bool {
for _, n := range arr {
if n == num {
return true
}
}
return false
}
3.2 算法优化
上述实现有一个效率问题：contains()函数在最坏情况下需要O(k)的时间复杂度。我们可以优化：
- 使用map来记录每个分组已有的数字
- 预先为每个分组维护一个set
优化后的实现：
go复制func canDivideIntoSubsets(nums []int, k int) bool {
if len(nums)%k != 0 {
return false
}
freq := make(map[int]int)
for _, num := range nums {
freq[num]++
}
maxGroups := len(nums) / k
for _, count := range freq {
if count > maxGroups {
return false
}
}
// 使用[]map[int]bool来记录每个分组已有的数字
groups := make([]map[int]bool, maxGroups)
for i := range groups {
groups[i] = make(map[int]bool)
}
// 按频率从高到低处理数字
uniqueNums := make([]int, 0, len(freq))
for num := range freq {
uniqueNums = append(uniqueNums, num)
}
sort.Slice(uniqueNums, func(i, j int) bool {
return freq[uniqueNums[i]] > freq[uniqueNums[j]]
})
for _, num := range uniqueNums {
count := freq[num]
assigned := 0
// 优先分配到当前元素较少的分组
sort.Slice(groups, func(i, j int) bool {
return len(groups[i]) < len(groups[j])
})
for i := 0; i < len(groups) && assigned < count; i++ {
if len(groups[i]) < k && !groups[i][num] {
groups[i][num] = true
assigned++
}
}
if assigned < count {
return false
}
}
return true
}
4. 边界条件与测试用例
4.1 常见边界情况
- 空数组：k>0时应该返回true（0可以被任何k整除）
- k=1：任何数组都可以满足条件
- 所有元素相同：
- 如果count <= len(nums)/k，可以满足
- 否则不行
- 数组长度正好等于k：只需要检查是否有重复元素
4.2 测试用例示例
go复制func TestCanDivideIntoSubsets(t *testing.T) {
tests := []struct {
nums []int
k int
want bool
}{
{[]int{1,2,3,3,4,4,5,6}, 4, true},
{[]int{1,2,3,3,3,4,4,5,6}, 3, true},
{[]int{1,2,3,3,3,4,4,5,6}, 4, false},
{[]int{1,1,1,1,2,2,2,2,3,3,3,3}, 4, true},
{[]int{1,1,1,1,1,1,1,1}, 4, false},
{[]int{}, 3, true},
{[]int{1,2,3,4}, 1, true},
{[]int{1,1,2,2,3,3}, 3, false},
}
for _, tt := range tests {
got := canDivideIntoSubsets(tt.nums, tt.k)
if got != tt.want {
t.Errorf("canDivideIntoSubsets(%v, %d) = %v, want %v", tt.nums, tt.k, got, tt.want)
}
}
}
5. 性能分析与优化
5.1 时间复杂度分析
- 频率统计：O(n)
- 唯一数字排序：O(m log m)，其中m是唯一数字的数量
- 分组分配：最坏情况下O(m * g * k)，其中g是分组数量
- 每次分配可能需要遍历所有分组
- 每个分组最多有k个元素
总体时间复杂度为O(n + m log m + m * g * k)。在最坏情况下，这可以简化为O(n log n)。
5.2 空间复杂度分析
- 频率map：O(m)
- 分组存储：O(n)
- 其他临时变量：O(1)
总体空间复杂度为O(n)。
5.3 进一步优化思路
- 优先队列：可以使用优先队列（堆）来维护当前元素最少的分组，这样每次可以优先分配到元素较少的分组
- 早期终止：在频率统计阶段，如果发现任何数字的出现次数超过maxGroups，可以立即返回false
- 并行处理：对于大规模数据，可以并行处理不同数字的分配
优化后的优先队列实现：
go复制import (
"container/heap"
"sort"
)
type Group struct {
elements map[int]bool
size int
index int // 堆索引
}
type PriorityQueue []*Group
func (pq PriorityQueue) Len() int { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool {
return pq[i].size < pq[j].size
}
func (pq PriorityQueue) Swap(i, j int) {
pq[i], pq[j] = pq[j], pq[i]
pq[i].index = i
pq[j].index = j
}
func (pq *PriorityQueue) Push(x interface{}) {
n := len(*pq)
group := x.(*Group)
group.index = n
*pq = append(*pq, group)
}
func (pq *PriorityQueue) Pop() interface{} {
old := *pq
n := len(old)
group := old[n-1]
group.index = -1
*pq = old[0 : n-1]
return group
}
func canDivideIntoSubsetsOpt(nums []int, k int) bool {
if len(nums)%k != 0 {
return false
}
freq := make(map[int]int)
for _, num := range nums {
freq[num]++
}
maxGroups := len(nums) / k
for _, count := range freq {
if count > maxGroups {
return false
}
}
// 初始化优先队列
pq := make(PriorityQueue, maxGroups)
for i := 0; i < maxGroups; i++ {
pq[i] = &Group{
elements: make(map[int]bool),
size: 0,
index: i,
}
}
heap.Init(&pq)
// 按频率从高到低处理数字
uniqueNums := make([]int, 0, len(freq))
for num := range freq {
uniqueNums = append(uniqueNums, num)
}
sort.Slice(uniqueNums, func(i, j int) bool {
return freq[uniqueNums[i]] > freq[uniqueNums[j]]
})
for _, num := range uniqueNums {
count := freq[num]
// 需要将num分配到count个不同的分组中
assigned := 0
var groupsToPushBack []*Group
for assigned < count && pq.Len() > 0 {
group := heap.Pop(&pq).(*Group)
if !group.elements[num] && group.size < k {
group.elements[num] = true
group.size++
assigned++
}
groupsToPushBack = append(groupsToPushBack, group)
}
// 将处理过的分组重新放回堆中
for _, group := range groupsToPushBack {
heap.Push(&pq, group)
}
if assigned < count {
return false
}
}
return true
}
6. 实际应用场景
这种分组算法在实际开发中有多种应用场景：
- 分布式任务分配：将任务按照某种特征分组，分配到不同的工作节点
- 数据库分片：将数据记录按照特定规则分配到不同的分片
- 负载均衡：将请求按照客户端特征分配到不同的服务器
- 内存管理：将对象按照大小分组管理
例如，在一个分布式计算系统中，我们可能需要：
- 将计算任务按照输入数据的特征分组
- 确保每个工作节点获得的任务数量相同
- 避免同一个工作节点处理相似的任务（防止热点）
7. 扩展与变种问题
7.1 变种问题1：允许部分元素不被分组
如果题目改为"最多可以形成多少个满足条件的子集合"，即允许部分元素不被包含在任何子集合中，该如何解决？
解决方案思路：
- 仍然先统计频率
- 找出所有数字的最小频率minFreq
- 最大可能分组数为min(minFreq * len(uniqueNums), len(nums)/k)
7.2 变种问题2：子集合大小可变
如果题目改为"子集合大小可以在某个范围内变化"，该如何解决？
解决方案思路：
- 使用回溯算法尝试各种可能的组合
- 结合剪枝策略提高效率
- 可能需要动态规划方法
7.3 变种问题3：多维特征分组
如果每个元素有多个特征，需要同时满足多个维度的分组条件，该如何解决？
解决方案思路：
- 将多维特征编码为单一键
- 使用复合键进行分组
- 可能需要更复杂的数据结构如多维哈希表
8. 经验总结与最佳实践
在实际实现这类分组算法时，有几点经验值得分享：
- 频率统计先行：总是先统计元素频率，这能帮助快速识别不可能的情况
- 贪心策略有效：在大多数情况下，优先处理出现频率最高的元素是最佳策略
- 合理选择数据结构：根据问题规模选择合适的数据结构，小规模数据可以用简单实现，大规模数据需要考虑更高效的方案
- 测试覆盖要全面：特别注意边界条件测试，如空数组、所有元素相同、k=1等情况
- 性能优化有度：不要过早优化，先确保正确性，再考虑性能提升
在Go语言实现中，还需要注意：
- map的使用要小心并发问题
- 切片操作要注意边界
- 优先队列的实现可以利用container/heap包
- 对于性能敏感的场景，可以考虑使用sync.Pool来重用对象