回溯法大集合（全排列+子集+目标和=target）（C++和java都有哦）

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合,每个数字可以使用多次

class Solution1 {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        dfs(candidates, target, 0);
        return res;
    }
    void dfs(vector<int>& candidates, int target, int start) {
        if (target == 0) {
            res.emplace_back(path);
            return;
        }
        if (target < 0)return;
        for (int i = start; i < candidates.size(); i++) {
            path.emplace_back(candidates[i]);//正着存入路径
            dfs(candidates, target - candidates[i], i);
            path.pop_back();
        }
    }
};

给定一个数组 candidates（有重复） 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
每个数字只可以使用一次

class Solution2 {
public:
    vector<vector<int>> res;//
    vector<int> path;
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtrack(candidates, target, 0);
        return res;
    }
    void backtrack(vector<int>& candidates, int target, int start) {
        if (target == 0) {
            res.emplace_back(path);
            return;
        }
        if (target < 0)return;
        for (int i = start; i < candidates.size(); i++) {
            if (i != start && candidates[i] == candidates[i - 1])continue;
            path.emplace_back(candidates[i]);
            backtrack(candidates, target - candidates[i], i + 1);
            path.pop_back();
        }
    }
};

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

class Solution3 {//
public:
    int k, n;
    vector<vector<int>> ans;
    vector<int> cur;
    vector<vector<int>> combinationSum3(int _k, int _n) {
        k = _k, n = _n;
        dfs(1, 0);
        return ans;
    }

    void dfs(int num, int cur_sum) {
        if (cur_sum == n && cur.size() == k) {
            ans.push_back(cur);
            return;
        }
        if (num == 10 || cur_sum > n || cur.size() > k)
            return;
        cur.push_back(num);//效率更高，倒着存入路径
        dfs(num + 1, cur_sum + num);
        cur.pop_back();
        dfs(num + 1, cur_sum);
    }
};

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。
动态规划

class Solution4 {//
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target + 1);
        dp[0] = 1;
        for (int i = 1; i <= target; i++) {
            for (int nu : nums) {
                if (nu <= i && dp[i] < INT_MAX - dp[i - nu]) {
                    dp[i] += dp[i - nu];
                }
            }
        }
        return dp[target];
    }
};

给定一个 没有重复 数字的序列，返回其所有可能的全排列。C(N,K)

class Solution5 {//   
public:
    vector<vector<int>> res;
    vector<vector<int>> permute(vector<int>& nums) {
        backtrack(nums, 0);
        return res;
    }
    void backtrack(vector<int>& nums, int start) {
        if (start == nums.size() - 1) {
            res.emplace_back(nums);
            return;
        }
        for (int i = start; i < nums.size(); i++) {
            swap(nums[i], nums[start]);
            backtrack(nums, start + 1);
            swap(nums[i], nums[start]);
        }

    }
};

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

class Solution6 {//
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> subsets(vector<int>& nums) {
        backtrack(nums, 0);
        return res;
    }
    void backtrack(vector<int>& nums, int start) {
        if (start == nums.size()) {
            res.emplace_back(path);
            return;
        }
        path.emplace_back(nums[start]);//倒着存入路径
        backtrack(nums, start + 1);
        path.pop_back();
        backtrack(nums, start + 1);
    }
};

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

class Solution7 {//
public:
    vector<vector<int>> res;

    vector<vector<int>> permuteUnique(vector<int>& nums) {

        backtrack(nums, 0);
        return res;
    }
    void backtrack(vector<int>& nums, int start) {
        if (start == nums.size()) {
            res.emplace_back(nums);
            return;
        }
        for (int i = start; i < nums.size(); i++) {
            sort(nums.begin() + start, nums.end());
            if (i != start && nums[i] == nums[i - 1])continue;
            swap(nums[i], nums[start]);
            backtrack(nums, start + 1);
            swap(nums[i], nums[start]);
        }

    }
};

java全排列去重版本

class Solution7 {//
    boolean[] vis;

    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        List<Integer> perm = new ArrayList<Integer>();
        vis = new boolean[nums.length];
        Arrays.sort(nums);
        backtrack(nums, ans, 0, perm);
        return ans;
    }

    public void backtrack(int[] nums, List<List<Integer>> ans, int idx, List<Integer> perm) {
        if (idx == nums.length) {
            ans.add(new ArrayList<Integer>(perm));
            return;
        }
        for (int i = 0; i < nums.length; ++i) {
            if (vis[i] || (i > 0 && nums[i] == nums[i - 1] && !vis[i - 1])) {
                continue;
            }
            perm.add(nums[i]);
            vis[i] = true;
            backtrack(nums, ans, idx + 1, perm);
            vis[i] = false;
            perm.remove(idx);
        }
    }
}


class Solution11 {//java
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtrack(candidates, target, 0);
        return res;
    }
    public void backtrack(int[] candidates, int target, int start) {
        if (target == 0) {
            res.add(new LinkedList(path));
            return;
        }
        if (target < 0)return;
        for (int i = start; i < candidates.length; i++) {
            path.add(candidates[i]);
            backtrack(candidates, target - candidates[i], i);
            path.remove(path.size() - 1);
        }
    }
};

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。java版本

class Solution {//
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backtrack(nums, 0);
        return res;
    }
    void backtrack(int[] nums, int start) {
        res.add(new LinkedList(path));//顺着存入路径
        if (start == nums.length)return;//可有可无
        for (int i = start; i < nums.length; i++) {
            path.add(nums[i]);
            backtrack(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

java字符串全排列

class Solution {
    List<String> res=new LinkedList<>();
    char []ans;
    public String[] permutation(String s) {
     ans=s.toCharArray();
     backtrack(0);
     return res.toArray(new String[res.size()]);
    }
    void backtrack(int start){
    if(start==ans.length-1){
      res.add(String.valueOf(ans));
      return ;
    }
    HashSet<Character> set=new HashSet<>();
    for(int i=start;i<ans.length;i++){
        if(set.contains(ans[i]))continue;
        set.add(ans[i]);
        swap(i,start);
        backtrack(start+1);
        swap(i,start);
    }
    }
     void swap(int a, int b) {
        char tmp = ans[a];
        ans[a] = ans[b];
        ans[b] = tmp;
    }
}