LeetCode 698. 划分为k个相等的子集（回溯）

最新推荐文章于 2022-09-21 13:30:26 发布

Michael阿明

最新推荐文章于 2022-09-21 13:30:26 发布

阅读量500

点赞数 1

分类专栏： LeetCode

本文链接：https://blog.csdn.net/qq_21201267/article/details/109649315

版权

LeetCode 专栏收录该内容

1849 篇文章 126 订阅

订阅专栏

文章目录

- 1. 题目
- 2. 解题

1. 题目

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

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

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

2. 解题

类似题目：LeetCode 416. 分割等和子集（动态规划）

普通回溯，超时，59 / 149 个通过测试用例

class Solution {
    int target;
    bool ans = false;
    int K;
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        K = k;
        if(sum%k) return false;
        target = sum/k;
        vector<int> partsum(k, 0);
        dfs(nums, partsum, 0);
        return ans;
    }
    void dfs(vector<int>& nums, vector<int>& partsum, int i)
    {
        if(ans == true) return;
        if(i == nums.size())
        {
            bool flag = true;
            for(int k = 0; k < K; k++)
            {
                if(partsum[k] != target)
                {
                    flag = false;
                    break;
                }
            }
            if(flag)
                ans = true;
            return;
        }
        for(int j = 0; j < K; ++j)
        {
            if(partsum[j]+nums[i] <= target)
            {
                partsum[j] += nums[i];
                dfs(nums, partsum, i+1);
                partsum[j] -= nums[i];
            }
        }
    }
};

优化，从大到小排序，可以尽快的让每个部分的和凑够

class Solution {
    int target;
    bool ans = false;
    int K;
public:
    bool canPartitionKSubsets(vector<int>& nums, int k) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        K = k;
        if(sum%k) return false;
        target = sum/k;
        sort(nums.rbegin(), nums.rend());//从大到小排序
        if(nums[0] > target)//最大的数超过了，不行
            return false;
        vector<int> partsum(k, 0);
        dfs(nums, partsum, 0);
        return ans;
    }
    void dfs(vector<int>& nums, vector<int>& partsum, int i)
    {
        if(ans == true) return;
        if(i == nums.size())
        {
            bool flag = true;
            for(int k = 0; k < K; k++)
            {
                if(partsum[k] != target)
                {
                    flag = false;
                    break;
                }
            }
            if(flag)
                ans = true;
            return;
        }
        for(int j = 0; j < K; ++j)
        {
            if(partsum[j]+nums[i] <= target)
            {
                partsum[j] += nums[i];
                dfs(nums, partsum, i+1);
                partsum[j] -= nums[i];
            }
        }
    }
};