LeetCode刷题day9——回溯法

77.组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

• 1 <= n <= 20
• 1 <= k <= n

class Solution {
public:
    void backtracking(int start, int n, int k, vector<int> & combine, vector<vector<int>> & res) {
        if(combine.size() == k) {
            res.emplace_back(combine);
            return;
        }
        for(int i = start; i <= n; i++) {//树的宽度
            combine.emplace_back(i);
            backtracking(i + 1, n, k, combine, res);//树的深度，往下钻
            combine.pop_back();//回溯
        }
    }

    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> res;
        vector<int> combine;
        backtracking(1,n,k,combine,res);
        return res;
    }
};

剪枝优化：

//剪枝
/*
例如：n = 6 ，k = 4。
path.size() == 1 的时候，接下来要选择 3 个数，搜索起点最大是 4，最后一个被选的组合是 [4, 5, 6]；
path.size() == 2 的时候，接下来要选择 2 个数，搜索起点最大是 5，最后一个被选的组合是 [5, 6]；

可以归纳出：
搜索起点的上界 + 接下来要选择的元素个数 - 1 = n
其中，接下来要选择的元素个数 = k - path.size()，整理得到：

搜索起点的上界 = n - (k - path.size()) + 1
所以，我们的剪枝过程就是：把 i <= n 改成 i <= n - (k - path.size()) + 1 ：
*/

class Solution {
public:
    void backtracking(int start, int n, int k, vector<int> & combine, vector<vector<int>> & res) {
        if(combine.size() == k) {
            res.emplace_back(combine);
            return;
        }
        for(int i = start; i <= n-(k-combine.size())+1; i++) {//剪枝
            combine.emplace_back(i);
            backtracking(i + 1, n, k, combine, res);
            combine.pop_back();
        }
    }

    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> res;
        vector<int> combine;
        backtracking(1,n,k,combine,res);
        return res;
    }
};

216.组合总和Ⅲ

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

• 只使用数字1到9
• 每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

• 2 <= k <= 9
• 1 <= n <= 60

class Solution {
public:
    void backtracking(int start, int k, int n, vector<int> & combine, vector<vector<int>> & res,int &sum) {
        if (combine.size() == k) {
            if(sum==n)
                res.emplace_back(combine);
            return;
        }
        for (int i=start; i<=9; i++) {
            combine.emplace_back(i);
            sum+=i;
            backtracking(i+1,k,n,combine,res,sum);
            sum-=combine.back();
            combine.pop_back();
        }
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>> res;
        vector<int> combine;
        int min=0;
        for(int i=1; i<=k; i++) {
            min+=i;
        }
        if(min>n)
            return res;
        int sum=0;
        backtracking(1,k,n,combine,res,sum);
        return res;
    }
};

剪枝优化：

class Solution {
public:
    void backtracking(int start, int k, int n, vector<int> & combine, vector<vector<int>> & res,int &sum) {
        if(sum>n)//剪枝1
            return;
        if(combine.size()+(9-start+1)<k)//剪枝2.剩余数字不够
            return;
        if (combine.size() == k) {
            if(sum==n)
                res.emplace_back(combine);
            return;
        }
        for (int i=start; i<=9-(k-combine.size())+1; i++) {//剪枝3.剩余数字不够
            combine.emplace_back(i);
            sum+=i;
            backtracking(i+1,k,n,combine,res,sum);
            sum-=combine.back();
            combine.pop_back();
        }
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>> res;
        vector<int> combine;
        /*int min=0;
        for(int i=1; i<=k; i++) {
            min+=i;
        }*/
        int min = k * (k + 1) / 2;  // 1 到 k 的和公式
        if(min>n)
            return res;

        int sum=0;
        backtracking(1,k,n,combine,res,sum);
        return res;
    }
};