回溯算法：集合划分问题

框架

回溯算法中需要考虑到的问题

• 路径，选择列表，结束条件

结束条件

// 结束条件：已经处理完所有数
if (track.size() == nums.length) {
    // 处理逻辑
}

// 结束条件：已经处理完所有球
if (index == nums.length) {
    // 处理逻辑
}

划分为k个相等的字串

class Solution {
public:

    bool dfs(vector<int>& nums, int index, vector<int>& v, int target){
        if(index == nums.size()){
            return true;
        }
        for(int i = 0; i < v.size(); ++i){
            //若不进行此步优化，则超时
            if(i && v[i] == v[i - 1]){
                continue;
            }
            v[i] += nums[index];
            if(v[i] <= target && dfs(nums, index + 1, v, target)){
                return true;
            }
            v[i] -= nums[index];
        }
        return false;
    }

    bool canPartitionKSubsets(vector<int>& nums, int k) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if(sum % k != 0){
            return false;
        }

        sort(nums.begin(), nums.end(), greater<int>());
        vector<int> v(k);
        return dfs(nums, 0 , v, sum / k);
    }
};

火柴拼正方形

class Solution {
public:
    bool dfs(int index, vector<int>& matchsticks, vector<int>& edges, int len){

        if(index == matchsticks.size()){
            return true;
        }
        for(int i = 0; i < edges.size(); i++){
            edges[i] += matchsticks[index];
            if(edges[i] <= len && dfs(index + 1, matchsticks, edges, len)){
                return true;
            }
            edges[i] -= matchsticks[index];
        }
        return false;
    }

    bool makesquare(vector<int>& matchsticks) {
        int sum = accumulate(matchsticks.begin(), matchsticks.end(), 0);
        if(sum % 4 != 0){
            return false;
        }
        //降序排序
        sort(matchsticks.begin(), matchsticks.end(), greater<int>());
        vector<int> edges(4);
        return dfs(0, matchsticks, edges, sum / 4);
    }
};

公平分发饼干

class Solution {
public:
    int distributeCookies(vector<int>& cookies, int k) {
        vector<int> v(k);
        return dfs(cookies, 0 , v , 0);
    }

    int dfs(vector<int>& cookies, int index, vector<int>& v, int maxx){
        if(index == cookies.size()){
            return maxx;
        }
        int ans = INT_MAX;
        for(int i = 0; i < v.size(); ++i){
            v[i] += cookies[index];
            ans = min(dfs(cookies, index + 1, v, max(v[i], maxx)) , ans);
            v[i] -= cookies[index];
        }
        return ans;
    }
};