代码随想录day27（集合，序列，全排列）

记录一下集合序列全排列的问题。

元素无重不可复选

//集合&组合
void backtrack(vector<int>& nums, int start) {
    // 回溯算法标准框架
    for (int i = start; i < nums.size(); i++) {
        // 做选择
        track.push_back(nums[i]);
        // 注意参数
        backtrack(nums, i + 1);
        // 撤销选择
        track.pop_back();
    }
}
//全排列
void backtrack(vector<int>& nums) {
    for (int i = 0; i < nums.size(); i++) {
        // 剪枝逻辑
        if (used[i]) {
            continue;
        }
        // 做选择
        used[i] = true;
        track.push_back(nums[i]);
        backtrack(nums);
        // 撤销选择
        track.pop_back();
        used[i] = false;
    }
}

元素可重不可复选

sort(nums.begin(), nums.end());
/* 组合/子集问题回溯算法框架 */
void backtrack(vector<int>& nums, int start) 
{
    //回溯算法标准框架
    for (int i = start; i < nums.size(); i++) {
        // 剪枝逻辑，跳过值相同的相邻树枝
        if (i > start && nums[i] == nums[i - 1]) {
            continue;
        }
        // 做选择
        track.push_back(nums[i]);
        // 注意参数
        backtrack(nums, i + 1);
        // 撤销选择
        track.pop_back();
    }
}

sort(nums.begin(), nums.end());

/* 排列问题回溯算法框架 */
void backtrack(vector<int>& nums, vector<bool>& used) {
    for (int i = 0; i < nums.size(); i++) {
        // 剪枝逻辑
        if (used[i]) {
            continue;
        }
        // 剪枝逻辑，固定相同的元素在排列中的相对位置
        if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
            continue;
        }
        // 做选择
        used[i] = true;
        track.push_back(nums[i]);

        backtrack(nums, used);
        // 撤销选择
        track.pop_back();
        used[i] = false;
    }
}

 元素无重可复选

/* 组合/子集问题回溯算法框架 */
void backtrack(vector<int>& nums, int start, vector<int>& track) {
    // 回溯算法标准框架
    for (int i = start; i < nums.size(); i++) {
        // 做选择
        track.push_back(nums[i]);
        // 注意参数
        backtrack(nums, i, track);
        // 撤销选择
        track.pop_back();
    }
}


/* 排列问题回溯算法框架 */
void backtrack(vector<int>& nums, vector<int>& track) {
    if (track.size() == nums.size()) {
        // 输出结果
        // ...
        return;
    }
    for (int i = 0; i < nums.size(); i++) {
        // 排除不合法的选择
        if (find(track.begin(), track.end(), nums[i]) != track.end()) {
            continue;
        }
        // 做选择
        track.push_back(nums[i]);
        backtrack(nums, track);
        // 撤销选择
        track.pop_back();
    }
}

1131分割回文串

class Solution {
public:
    vector<vector<string>>res;
    vector<string>path;
    vector<vector<string>> partition(string s) 
    {
        dg(s,0);
        return res;
    }
    void dg(string s,int index)
    {
        if(index==s.size())
        {
            res.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++)
        {
            string st=s.substr(index,i-index+1);
            if(hw(st))
            {
                path.push_back(st);
            }
            else continue;
            dg(s,i+1);
            path.pop_back();
        }
    }
    bool hw(string s)
    {
        int l=0,r=s.size()-1;
        while(l<=r)
        {
            if(s[l]!=s[r])return false;
            l++;
            r--;
        }
        return true;
    }
};