代码随想录算法训练营第22天 | LeetCode77.组合、LeetCode216.组合总和III、LeetCode17.电话号码的字母组合

目录

LeetCode77.组合

LeetCode216.组合总和III

LeetCode17.电话号码的字母组合 

---

LeetCode77.组合

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

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

思路：关于组合、切割、子集、排列、棋盘等类的问题，一般的处理方法就是回溯。

回溯并不是一个高效的解决办法，是一个暴力解法，但是有的问题只能使用回溯来解决，所以回溯的方法还是应该掌握。

这里是给定一个区间，给出k个元素的组合，就可以使用回溯。在回溯里面，首先是对终止条件进行判断，然后一个for循环里面处理单层逻辑，期间有自身递归的调用，还有回溯操作。

起始整体思路还是比较简单的，使用path来记录录入的元素，当元素个数达到k时，就加入result，然后跳出递归，回溯，继续添加下一个元素。

    vector<vector<int>> result;//记录最终结果
    vector<int> path;//记录每次的单个结果
    void backtracking(int n, int k, int startIndex){
        if(path.size() == k){
            result.push_back(path);
            return;
        }//结束条件，当path的大小为k时，加入result，并返回
        for(int i = startIndex; i <= n; i ++){
            path.push_back(i);//处理
            backtracking(n, k, i + 1);//递归
            path.pop_back(); //回溯
        }
    }
    vector<vector<int>> combine(int n, int k) {
        result.clear();
        path.clear();
        backtracking(n, k, 1);
        return result;
    }

当然，回溯虽然有点像暴力求解，但是也不是说没办法优化，我们可以使用判断来进行剪枝操作，例如下面的代码就是对上面代码的一个精化，在for循环的地方对元素起始位置限制，当剩余元素就算全部录入也没办法达到k的大小时，直接就可以停止了，避免后续继续递归。

    vector<vector<int>> result;//记录最终结果
    vector<int> path;//记录每次的单个结果
    void backtracking(int n, int k, int startIndex){
        if(path.size() == k){
            result.push_back(path);
            return;
        }//结束条件，当path的大小为k时，加入result，并返回
        for(int i = startIndex; i <= n - (k - path.size()) + 1; i ++){//这里进行了剪枝优化
            path.push_back(i);//处理
            backtracking(n, k, i + 1);//递归
            path.pop_back(); //回溯
        }
    }
    vector<vector<int>> combine(int n, int k) {
        result.clear();
        path.clear();
        backtracking(n, k, 1);
        return result;
    }

时间复杂度：O(n*2^n)

空间复杂度：O(n)

LeetCode216.组合总和III

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

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

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

思路：这里和上面的题的思路一致，上面搞懂了，这道题就变得十分简单。

不过需要注意一点的就是，当元素录入个数达到k后，不管最后有没有满足和为n，都需要返回，所以最好是进行两层判断，不要一个判断就把path的大小和是否和为n判断了，否则没办法返回，会出现超限问题。

    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;//记录相加和
    void backtracking(int k, int n, int startIndex, int sum){
        if(path.size() == k){
            if(sum == n) result.push_back(path);
            return;//这里只要path的size为k了，不管是否满足了题意，都需要返回了，注意一下
        }
        for(int i = startIndex; i <= 9; i ++){
            path.push_back(i);
            sum += i;
            backtracking(k, n, i + 1, sum);
            path.pop_back();//这里开始回溯
            sum -= i;
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear();
        path.clear();
        backtracking(k, n, 1, sum);
        return result;
    }

这里我们依然对上面的代码进行优化，除了for循环的地方外，可以在递归进入地方对sum的和进行判断，当值已经大于了n后，就直接可以返回了，因为再往下加，也只会越来越大，没必要再进行了。

    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;//记录相加和
    void backtracking(int k, int n, int startIndex, int sum){
        if(sum > n) return; //当sum已经大于了n后，没有必要再进行后面的处理了，因为会越加越大
        if(path.size() == k){
            if(sum == n) result.push_back(path);
            return;//这里只要path的size为k了，不管是否满足了题意，都需要返回了，注意一下
        }
        for(int i = startIndex; i <= 9 - (k - path.size()) + 1; i ++){//这里优化了起始位置i
            path.push_back(i);
            sum += i;
            backtracking(k, n, i + 1, sum);
            path.pop_back();//这里开始回溯
            sum -= i;
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear();
        path.clear();
        backtracking(k, n, 1, sum);
        return result;
    }

时间复杂度：O(n*2^n)

空间复杂度：O(n)

LeetCode17.电话号码的字母组合 

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

思路：电话号码的字母组合，核心思想仍然是回溯。

这里需要将数字上的字母映射下来，方便后续进行访问。递归的次数和digits的大小有关，每一次递归都是访问下一个数字的字母，这样能够在所有递归结束后，返回所有组合。

    vector<string> result;//存放最终结果
    string path;//记录单次结果
    //使用digits_map将数字对应的字母记录下来
    vector<string> digits_maps = {" "," ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    void backtracking(int k, int index, string digits){
        if(path.size() == k){
            result.push_back(path);
            return;
        }
        if(index >= digits.size()) return;//当index大于等于了digits的size,直接返回
        for(int i = 0; i < digits_maps[digits[index] - '0'].size(); i ++){
            path.push_back(digits_maps[digits[index] - '0'][i]);
            backtracking(k, index + 1, digits);//进行递归处理，处理每一个字符对应的字母
            path.pop_back();//回溯
        }
    }
    vector<string> letterCombinations(string digits) {
        result.clear();
        path.clear();
        if(digits.size() == 0) return result;
        backtracking(digits.size(), 0, digits);
        return result;
    }

时间复杂度：O(3^n*4^m)

空间复杂度：O(3^n*4^m)

感谢你的阅读，希望我的文章能够给你帮助，如果有帮助，麻烦点赞加收藏，或者点点关注，非常感谢。

如果有什么问题欢迎评论区讨论！