【Lintcode】836. Partition to K Equal Sum Subsets

题目地址：

https://www.lintcode.com/problem/partition-to-k-equal-sum-subsets/description

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

思路是DFS + 剪枝。先排除掉不可能的情形，例如$A$总和不能被$k$整除，那直接返回false。这个问题是NPC问题，只能暴力搜索。但可以有一些剪枝的方式。例如，如果一个数出现了若干次，那么我们只考虑连续的一段去组成一个子集；可以对$A$从小到大排序，这样可以先对大的数进行搜索，起到剪枝的效果。代码如下：

import java.util.Arrays;

public class Solution {
    /**
     * @param nums: a list of integer
     * @param k: an integer
     * @return: return a boolean, denote whether the array can be divided into k non-empty subsets whose sums are all equal
     */
    public boolean partitiontoEqualSumSubsets(int[] nums, int k) {
        // write your code here
        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);
        
        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个子集了，判断一下是否所有数都被用过了，如果是，则返回true，否则返回false
        if (count == k) {
            for (int i = 0; i < used.length; i++) {
                if (!used[i]) {
                    return false;
                }
            }
            
            return true;
        }
        
        // 如果已经搜出一个和为sum的子集了，则重置curSum搜索下一个子集
        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)$。