当前位置：首页 > news >正文

Leetcode 698-划分为k个相等的子集

news 来源：原创 2025/5/20 1:00:27

给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。

示例 1：

输入： nums = [4, 3, 2, 3, 5, 2, 1], k = 4
输出： True
说明：有可能将其分成 4 个子集（5），（1,4），（2,3），（2,3）等于总和。
示例 2:

输入: nums = [1,2,3,4], k = 3
输出: false

提示：

1 <= k <= len(nums) <= 16
0 < nums[i] < 10000
每个元素的频率在 [1,4] 范围内

题解（回溯法）

题解参考自LFool
把集合中数字想象成球，把子集想象成桶
遍历数组计算总和sum，如果sum%k!=0直接返回false
否则令target=sum/k，计算每个桶内球的值之和是否等于sum/k

法一、球选择桶

在这里插入图片描述

dfs(nums,target,idx,bucket)

递归终止:idx越界，已经处理完所有球(idx==nums.length)
本层操作：bucket[i]+=nums[idx];
剪枝：nums[idx]+bucket[i]>target
向下递归：如果有一个路径为true则返回true
if(dfs(nums,idx+1,bucket,k,target)) return true;
回溯：
bucket[i]-=nums[idx]

class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
        if (sum % k != 0) return false;
        int target = sum / k;
        int[] bucket = new int[k];
        return dfs(nums,0,bucket,k,target);
    }

    private boolean dfs(int[] nums, int idx, int[] bucket, int k, int target){
        // 递归终止：idx越过数组边界，此时已经处理完所有球
        if (idx == nums.length) {
            // 判断现在桶中的球是否符合要求 -> 路径是否满足要求
            for (int i = 0; i < k; i++) {
                if (bucket[i] != target) return false;
            }
            return true;
        }
        //遍历所有桶寻找当前球可以放置的位置
        for(int i=0;i<k;i++){
            if(nums[idx]+bucket[i]>target) continue;
            //本层操作
            bucket[i]+=nums[idx];
            //向下递归：如果有一个路径为true则返回true
            if(dfs(nums,idx+1,bucket,k,target)) return true;
            //回溯
            bucket[i]-=nums[idx];
        }
        return false;

    }
}

法二桶选择球

class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
        if (sum % k != 0) return false;
        int target = sum / k;
        int[] bucket = new int[k];
        return dfs(nums,0,bucket,k,target);
    }

    private boolean dfs(int[] nums, int idx, int[] bucket, int k, int target){
        // 递归终止：idx越过数组边界，此时已经处理完所有球
        if (idx == nums.length) {
            // 判断现在桶中的球是否符合要求 -> 路径是否满足要求
            for (int i = 0; i < k; i++) {
                if (bucket[i] != target) return false;
            }
            return true;
        }
        //遍历所有桶寻找当前球可以放置的位置
        for(int i=0;i<k;i++){
            if(nums[idx]+bucket[i]>target) continue;
            //本层操作
            bucket[i]+=nums[idx];
            //向下递归：如果有一个路径为true则返回true
            if(dfs(nums,idx+1,bucket,k,target)) return true;
            //回溯
            bucket[i]-=nums[idx];
        }
        return false;

    }
}
收起