题目描述
思路
状态压缩+记忆化搜索
首先计算数组的和all,如果all不是k的倍数,那么不可能有合法方案,此时可以直接返回false。
否则需要得到k个和为persum=all/k的集合,可以每次尝试选择一个还在数组中的数,若选择后已选数字和等于persum则说明已经得到了一个集合,而已选数字和大于persum时,不可能形成一个集合所以停止继续向下选择新的数字。
又因为n满足1<=n<=16,所以可以用一个整数S来表示当前可用的数字集合:从低位到高位,第i位为1则表示数字nums[i]可以使用,否则表示nums[i]已被使用。为了避免相同状态的重复计算,可以用dp[S]来表示在可用的数字状态为S的情况下是否可行,初始全部状态记录为可行状态True。这样就可以通过记忆化搜索的方式求解原始状态的可行性,当状态集合不存在任何数字是,即S=0时,表示原始数组可以按照题目要求来进行分配,此时返回True即可。
Python实现
class Solution:
def canPartitionKSubsets(self, nums: List[int], k: int) -> bool:
all = sum(nums)
if all % k:
return False
persum = all // k
nums.sort()
if nums[-1] > persum:
return False
n = len(nums)
@lru_cache(None)
def dfs(s, p):
if s == 0:
return True
for i in range(n):
if nums[i] + p > persum:
break
if s >> i & 1 and dfs(s ^ (1 << i), (p + nums[i]) % persum):
return True
return False
return dfs((1<<n)-1, 0)
Java实现
class Solution {
int[] nums;
int per, n;
boolean[] dp;
public boolean canPartitionKSubsets(int[] nums, int k) {
this.nums = nums;
int all = Arrays.stream(nums).sum();
if (all % k != 0) {
return false;
}
per = all / k;
Arrays.sort(nums);
n = nums.length;
if (nums[n - 1] > per) {
return false;
}
dp = new boolean[1 << n];
Arrays.fill(dp, true);
return dfs((1 << n) - 1, 0);
}
public boolean dfs(int s, int p) {
if (s == 0) {
return true;
}
if (!dp[s]) {
return dp[s];
}
dp[s] = false;
for (int i = 0; i < n; i++) {
if (nums[i] + p > per) {
break;
}
if (((s >> i) & 1) != 0) {
if (dfs(s ^ (1 << i), (p + nums[i]) % per)) {
return true;
}
}
}
return false;
}
}
C++实现
class Solution {
public:
bool canPartitionKSubsets(vector<int>& nums, int k) {
int all = accumulate(nums.begin(), nums.end(), 0);
if (all % k > 0) {
return false;
}
int per = all / k;
sort(nums.begin(), nums.end());
if (nums.back() > per) {
return false;
}
int n = nums.size();
vector<bool> dp(1 << n, true);
function<bool(int,int)> dfs = [&](int s, int p)->bool {
if (s == 0) {
return true;
}
if (!dp[s]) {
return dp[s];
}
dp[s] = false;
for (int i = 0; i < n; i++) {
if (nums[i] + p > per) {
break;
}
if ((s >> i) & 1) {
if (dfs(s ^ (1 << i), (p + nums[i]) % per)) {
return true;
}
}
}
return false;
};
return dfs((1 << n) - 1, 0);
}
};