【Leetcode】698. Partition to K Equal Sum Subsets

题目地址：

https://leetcode.com/problems/partition-to-k-equal-sum-subsets/

给定一个数组$A$，和一个正整数$k$，问是否能将$A$拆为$k$个子集，并且每个子集的和相等。

法1：DFS + 剪枝，依次枚举子集。设总和是$s$，可以每次枚举哪个数加入当前枚举的子集，并不断搜索出和为$s/k$的子集，只要搜到了$k$个满足条件的子集就返回true。详细思路可以参考https://blog.csdn.net/qq_46105170/article/details/109153610。代码如下：

import java.util.Arrays;

public class Solution {
    public boolean canPartitionKSubsets(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return false;
        }
        
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        
        if (sum % k != 0) {
            return false;
        }
        
        sum /= k;
        Arrays.sort(nums);
        reverse(nums);
        
        if (nums[nums.length - 1] >= 0 && nums[0] > sum) {
            return false;
        }
        
        return dfs(nums, 0, sum, new boolean[nums.length], 0, k);
    }
    
    private boolean dfs(int[] nums, int curSum, int sum, boolean[] used, int count, int k) {
    	// 如果得到了k个和为sum的子集，则返回true
        if (count == k) {         
            return true;
        }
        
        // 如果搜出来了一个和为sum的子集，则将count加一，重置curSum并继续搜索，如果能搜出来，则返回true
        if (curSum == sum && dfs(nums, 0, sum, used, count + 1, k)) {
            return true;
        }
        
        // 枚举哪个数加入当前枚举的子集
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) {
                continue;
            }
            
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                continue;
            }
            
            if (curSum + nums[i] <= sum) {
                used[i] = true;
                if (dfs(nums, curSum + nums[i], sum, used, count, k)) {
                    return true;
                }
                // 回溯的时候要恢复现场
                used[i] = false;
            }
        }
        
        return false;
    }
    
    private void reverse(int[] nums) {
        for (int i = 0, j = nums.length - 1; i < j; i++, j--) {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
}

时间复杂度是指数级的，空间$O(n)$。

法2：记忆化搜索 + 状态压缩。思路和上面是一样的。这一次在搜索的时候，将每次搜索的状态都记下来，下一次搜到重复状态的时候直接返回false，从而避免重复搜索。这里的状态指的是已经用了哪些数，可以由一个32位整数的二进制位来表示，$1$表示选过，$0$表示没有选。代码如下：

import java.util.Arrays;

public 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;
        }
        
        Arrays.sort(nums);
        reverse(nums);
        
        if (nums[0] > sum / k && nums[nums.length - 1] >= 0) {
            return false;
        }
        
        return dfs(0, sum, new boolean[1 << nums.length], nums, sum / k);
    }
    
    // remain表示还没用过的数字总和，used代表nums里的数选取的状态
    private boolean dfs(int used, int remain, boolean[] set, int[] nums, int target) {
        if (remain == 0) {
            return true;
        }
        
        // 走到了已经访问过的状态，则返回false
        if (set[used]) {
            return false;
        }
        
        // 记录当前选取状态为已经访问过
        set[used] = true;
        // 算一下接下来需要凑多少数；如果remain能整除target，那说明已经得到了一个子集，那就继续凑下一个子集，即extra取target；
        // 如果remain不能整除target，那就需要再凑remain % target这么多数来凑够一个子集；
        // 综上，就有extra = (remain - 1) % target + 1。
        int extra = (remain - 1) % target + 1;
        for (int i = 0; i < nums.length; i++) {
        	// 如果nums[i]没用过，又小于extra，那就可以加进当前枚举的子集
            if (nums[i] <= extra && ((used >> i) & 1) == 0) {
                if (dfs(used | (1 << i), remain - nums[i], set, nums, target)) {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    private void reverse(int[] nums) {
        for (int i = 0, j = nums.length - 1; i < j; i++, j--) {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
}

时间复杂度仍然是指数级，空间$O(2^n)$。

法3：DFS + 剪枝，枚举每个数应该加到哪个group中。先开一个长度为$k$的数组，然后依次尝试将每个数填到其中某个组中，同时保持每个组里的数都小于等于$s/k$，填完了以后就继续进入下一层递归搜索。当数组里的数都加入group中的时候，说明找到了一个分组方式了，返回true。代码如下：

import java.util.Arrays;

public 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;
        }
        
        Arrays.sort(nums);
        reverse(nums);
        
        sum /= k;
        if (nums[nums.length - 1] >= 0 && nums[0] > sum) {
            return false;
        }
        
        int[] group = new int[k];
        int i = 0;
        while (i < nums.length && nums[i] == sum) {
            group[i++] = sum;
        }
        
        return dfs(i, nums, i, group, sum);
    }
    
    private boolean dfs(int pos, int[] nums, int start, int[] group, int target) {
    	// 如果全体数字都加入完毕了，就得到了一个合法的分组方式，返回true
        if (pos == nums.length) {
            return true;
        }
        
        // 枚举nums[pos]这个数应该被加入哪个组里
        for (int i = start; i < group.length; i++) {
            if (group[i] + nums[pos] <= target) {
                group[i] += nums[pos];
                if (dfs(pos + 1, nums, start, group, target)) {
                    return true;
                }
                // 回溯的时候恢复现场
                group[i] -= nums[pos];
            }
        }
        
        return false;
    }
    
    private void reverse(int[] nums) {
        for (int i = 0, j = nums.length - 1; i < j; i++, j--) {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
}

时间复杂度也是指数级别的，空间$O(n)$，递归栈深度。