leetcode-698-Partition to K Equal Sum Subsets

问题

题目：[leetcode-698]

思路

能想到的是搜索的思路，但是不知道怎么用。
参考了[698. Partition to K Equal Sum Subsets]

看了别人的代码，知道这个题搜索的技巧在于，对于每一个元素nums[i]，枚举每一个子数组的当前位置。这也是一种枚举策略。并且，这个题目只有这么理解枚举，才能做出来。

代码(wa)

下面枚举的思路没有错，就是这个思路。但是TLE。

class Solution {
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {

        int sz = nums.size();
        int sum = 0;
        for(int i = 0; i < sz; ++i) {
            sum += nums[i];
        }
        if( sum % k != 0 ) return false;
        else{

            vector<int> ret(k , 0);
            bool flag = false;

            dfs( 0, nums, sum/k, ret, flag );
            return flag;
        }
    }
private:
    void dfs( int depth, vector<int>& nums, int target, vector<int>& ret, bool& flag ) {
        if( flag ) return;
        if( depth == nums.size() ) {
            int k = ret.size();
            for(int i = 0; i < k; ++i) {
                if( ret[i] != target ) {
                    flag = false;
                    return;
                }
            }
            flag = true;
        }
        else {
            int k = ret.size();
            for( int i = 0; i < k; ++i ) {
                if( ret[i] + nums[depth] <= target ) {
                    ret[i] += nums[depth];
                    dfs( depth + 1, nums, target, ret, flag );
                    ret[i] -= nums[depth];
                }
            }
        }
    }
};

代码1(ac)

class Solution {
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {

        int sz = nums.size();
        int sum = 0;
        for(int i = 0; i < sz; ++i) {
            sum += nums[i];
        }
        if( sum % k != 0 ) return false;
        for( int i = 0; i < sz; ++i ) if( nums[i] > sum/k ) return false; 

        /* 排序后倒置数组，可以ac。应该是刚好能过，看建议的方法要记忆化搜索了。下面的方法并没有记忆化搜索 */
        sort( nums.begin(), nums.end() );
        vector<int> new_nums;
        for( int i = 0; i < sz; ++i ) new_nums.push_back(nums[sz-1-i] );

        vector<int> ret(k , 0);
        bool flag = false;

        dfs( 0, new_nums, sum/k, ret, flag );
        return flag;

    }
private:
    void dfs( int depth, vector<int>& nums, int target, vector<int>& ret, bool& flag ) {
        if( flag ) return;
        if( depth == nums.size() ) {
            int k = ret.size();
            for(int i = 0; i < k; ++i) {
                if( ret[i] != target ) {
                    flag = false;
                    return;
                }
            }
            flag = true;
        }
        else {
            int k = ret.size();
            for( int i = 0; i < k; ++i ) {
                if( ret[i] + nums[depth] <= target ) {
                    ret[i] += nums[depth];
                    dfs( depth + 1, nums, target, ret, flag );
                    ret[i] -= nums[depth];
                }
            }
        }
    }
};