03.03回溯法

class Solution {
public:
    vector<int> temp;
    vector<vector<int>> ans;
    void dfs(int cur,int n,int k)
    {
        //剪枝 temp 长度加上区间 [cur, n] 的长度小于 k，不可能构造出长度为 k 的 temp
        if(temp.size()+(n-cur+1)<k)
        {
            return;
        }
        if(temp.size()==k)
        {
            ans.push_back(temp);
            return;
        }
        temp.push_back(cur);
        dfs(cur+1,n,k);
        temp.pop_back();
        dfs(cur+1,n,k);

    }

    vector<vector<int>> combine(int n, int k) {
        dfs(1,n,k);   
        return ans;
    }
};

class Solution {
public:
    void dfs(vector<int>& candidates, int target, vector<vector<int>>& ans, vector<int>& combination, int idx)
    {
        if(candidates.size()==idx)
        {
            return;
        }
        if(target==0)
        {
            ans.push_back(combination);
            return;
        }
        //直接跳过
        dfs(candidates,target,ans,combination,idx+1);
        //选择当前数
        if(target-candidates[idx]>=0)
        {
            combination.emplace_back(candidates[idx]);
            //继续添加当前元素
            dfs(candidates,target-candidates[idx],ans,combination,idx);
            combination.pop_back();
        }

    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector< vector<int> >ans;
        vector<int> combination;
        dfs(candidates,target,ans,combination,0);
        return ans;

    }
};

class Solution {
private:
//freq 哈希表记录重复的元素数
    vector<pair<int, int>> freq;
    vector<vector<int>> ans;
    vector<int> sequence;

public:

    //pos指的是 数组candidates中第POS个数
    //rest 表示为目标值
    void dfs(int pos, int rest) {
        //符合要求
        if (rest == 0) {
            ans.push_back(sequence);
            return;
        }
        //剪枝操作 到达哈希表的最后一个 或者rest小于之后的数 
        if (pos == freq.size() || rest < freq[pos].first) {
            return;
        }

        dfs(pos + 1, rest);
        //应该使用几个重复的数
        int most = min(rest / freq[pos].first, freq[pos].second);
        for (int i = 1; i <= most; ++i) {
            //调用了几个重复的数
            sequence.push_back(freq[pos].first);
            dfs(pos + 1, rest - i * freq[pos].first);
        }
        for (int i = 1; i <= most; ++i) {
            sequence.pop_back();
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        for (int num: candidates) {
            if (freq.empty() || num != freq.back().first) {
                freq.emplace_back(num, 1);
            } else {
                ++freq.back().second;
            }
        }
        dfs(0, target);
        return ans;
    }
};

class Solution {
public:
    void backtrack(vector<vector<int>>& res, vector<int>& output, int first, int len)
    {
        if(first==len)
        {
            res.push_back(output);
            return;
        }
        for(int i=first;i<len;i++)
        {
            swap(output[i],output[first]);
            backtrack(res,output,first+1,len);
            swap(output[i],output[first]);
        }

    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        backtrack(res,nums,0,(int)nums.size());
        return res;

    }
};

class Solution {
    vector<int> vis;
public:
    void backtrack(vector<int>& nums, vector<vector<int>>& ans, int idx, vector<int>& perm)
    {
        if(idx==nums.size())
        {
            ans.push_back(perm);
        }
        for(int i=0;i<nums.size();i++)
        {
            //[1,1,1]保证了[未填入，未填入，未填入]->[填入，未填入，未填入]->[填入，填入，未填入]->[填入，填入，填入]
            //vis[i]之前已经填入了
            if(vis[i]||(i>0&&nums[i]==nums[i-1]&&vis[i-1]))
            {
                continue;
            }
            perm.push_back(nums[i]);
            vis[i]=1;
            backtrack(nums,ans,idx+1,perm);
            vis[i]=0;
            perm.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> ans;
        vector<int> perm;
        vis.resize(nums.size());
        sort(nums.begin(),nums.end());
        backtrack(nums,ans,0,perm);
        return ans;


    }
};

 

 

class Solution {
public:
    void backtrack(vector<string>& ans, string& cur, int open, int close, int n)
    {
        if(cur.size()==n*2)
        {
            ans.push_back(cur);
        }
        if(open<n)
        {
            cur.push_back('(');
            backtrack(ans, cur, open + 1, close, n);
            cur.pop_back();
        }
        if(open>close)
        {
            cur.push_back(')');
            backtrack(ans, cur, open , close+ 1, n);
            cur.pop_back();
        }
    }
    vector<string> generateParenthesis(int n) {
        vector<string> result;
        string current;
        backtrack(result,current,0,0,n);
        return result;
    }
};