leetcode——第698题——划分为k个相等的子集

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/partition-to-k-equal-sum-subsets
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
/*
这题用全排列的话，时间复杂度就是 O(n！) 其中n=nums.size()
所以就是从 n! 这里考虑优化的问题，利用 二进制位进行优化，将时间复杂度降为 O(k*2^n)

感觉这道题是 类似于 有重复元素的组合问题

1、为什么要进行移位运算呢？
当移位次数为8或16时则可能获得最大的效率。
当乘数比较大，移位次数增多，程序会采用循环的逐位移动，这样的效率反而不高。

但是~但是~这里采用n位二进制进行进行计算，并不是考虑到效率问题，而是采用 0 或 1 便于标记是否使用过该元素

将二维数组这么设定，可以直接进行为二进制的移位运算，而无序利用标记数组的形式来标定是否使用过该元素
此时就不考虑他的十进制是多少，只需要考虑二进制的表示，

但是位运算是有上限的，一般 n=20 以下这么用，

想来想去，感觉就是相当于组合问题呢。

2、关于时间复杂度
感觉还是 for 循环要走 n 步，for循环里面的 backtrack 函数要走 n 步，for 循环外面还有一个 backtrack 要走 k，
所以时间复杂度就是 O(k*2^n)

那个 for 的运行实际上还是要走 backtrack。

3、回溯 + dp

*/

public:
    bool canPartitionKSubsets(vector<int>& nums, int k) 
    {
        int sum = accumulate(nums.begin(), nums.end(), 0);

        if(sum % k != 0)    return false;
        target = sum / k;

        // 这里定义为 1 << nums.size() 的形式，令 n = nums.size()
        // 其的十进制是 2^n ，二进制就是 第 n 位是1 ，其余为 0 的一串 二进制数，
        // 注意这里是从 0 开始数的。
        memo = vector<vector<int>>(k+ 1, vector<int>(1 << nums.size(), -1));

        return backtrack(nums, 0, k, 0);
    }

private:
    int target = 0;
    vector<vector<int>> memo;
    bool backtrack(vector<int>& nums, int state, int k, int sum)
    {
        // 有两次回溯，所以在计算时间复杂度时要注意。
        if(k == 0)  return true;
        if(sum > target)    return false;
        if(sum == target)   return backtrack(nums, state, k - 1, 0);
        if(memo[k][state] >= 0)     return memo[k][state];

        bool res = false;
        for(int i = 0; i < nums.size(); ++i)
        {
            if(nums[i] > target)    return false;
            if(state & 1 << i)     continue;

            res |= backtrack(nums, state | 1 << i, k, sum + nums[i]);
        } 
        return memo[k][state] = res;
    }
};