代码随想录算法训练营第二十二天| 77. 组合 216.组合总和III 17.电话号码的字母组合

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

思路：

给定 n 和 k，要求从 [1, n] 范围内选出 k 个数字的所有组合。我们可以用回溯的方法来解决：

1. 初始状态: 我们从空组合开始，然后逐步增加元素。

2. 选择: 从当前的数字 start 开始，我们可以选择一个数字 i（start <= i <= n）加入当前组合，然后递归地去选择下一个数字。

3. 递归: 在每次选择一个数字加入当前组合后，我们递归地选择下一个数字，直到组合的长度达到 k。一旦组合长度达到 k，我们就将其加入到结果集中。

4. 撤销选择: 当我们递归返回时（即完成了某个数字的全部后续选择的探索），我们会将这个数字从组合中移除，尝试其他可能的数字。

5. 结束条件: 当当前组合的长度达到 k，或当所有可能的数字都被尝试过，我们就结束当前递归的探索。

上代码：

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result; // 保存所有组合的结果
        vector<int> currentCombination; // 当前组合
        backtrack(result, currentCombination, n, k, 1); // 从数字1开始
        return result;
    }
    
private:
    void backtrack(vector<vector<int>>& result, vector<int>& currentCombination, int n, int k, int start) {
        // 如果当前组合的长度等于k，将其添加到结果中
        if (currentCombination.size() == k) {
            result.push_back(currentCombination);
            return;
        }
        
        // 从当前数字开始到n，逐个尝试
        for (int i = start; i <= n; ++i) {
            currentCombination.push_back(i); // 将当前数字加入到当前组合
            backtrack(result, currentCombination, n, k, i + 1); // 递归调用，开始下一个数字
            currentCombination.pop_back(); // 回溯，移除最后一个数字
        }
    }
};

216.组合总和III

题目：

找出所有相加之和为 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

思路：

可以使用回溯的方法来解决这个问题。

在这个问题中，我们需要找到所有满足条件的 k 个数的组合，这些数字相加的和为 n，并且只能使用数字 1 到 9，且每个数字最多使用一次。

回溯的思路

1. 选择和决策: 从数字 1 开始，我们可以选择一个数字加入当前组合，然后继续选择下一个数字，直到组合长度达到 k 或组合和达到 n。

2. 递归探索: 每次选择一个数字后，进入下一层的递归，继续选择下一个数字。如果发现当前组合的和超过了 n 或组合长度超过了 k，则可以立即停止当前路径的探索，回溯到上一步。

3. 撤销选择（回溯）: 如果递归到某个阶段后，发现当前路径不符合要求，我们就撤销最近的选择，回溯到上一个状态，尝试其他可能的选择。

4. 结束条件: 当当前组合的长度等于 k 且和等于 n 时，将当前组合加入到结果中。当所有可能的数字都被尝试过，或者组合的和已经超过 n 时，结束当前递归。

上代码：

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>> result; // 保存所有组合的结果
        vector<int> currentCombination; // 当前组合
        backtrack(result, currentCombination, k, n, 1); // 从数字1开始
        return result;
    }
    
private:
    void backtrack(vector<vector<int>>& result, vector<int>& currentCombination, int k, int n, int start) {
        // 如果当前组合的长度等于k且和等于n，将其添加到结果中
        if (currentCombination.size() == k && n == 0) {
            result.push_back(currentCombination);
            return;
        }
        
        // 如果当前组合的长度超过k，或和已经小于0，则直接返回
        if (currentCombination.size() >= k || n < 0) {
            return;
        }
        
        // 从当前数字开始到9，逐个尝试
        for (int i = start; i <= 9; ++i) {
            currentCombination.push_back(i); // 将当前数字加入到当前组合
            backtrack(result, currentCombination, k, n - i, i + 1); // 递归调用，开始下一个数字
            currentCombination.pop_back(); // 回溯，移除最后一个数字
        }
    }
};

17.电话号码的字母组合

题目：

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

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

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

• 0 <= digits.length <= 4
• digits[i] 是范围 ['2', '9'] 的一个数字。

思路：

这个问题可以通过回溯算法来解决。

我们需要从给定的数字字符串 digits 中生成所有可能的字母组合。每个数字对应多个字母，因此我们需要逐个尝试每个数字可能的字母组合。

回溯思路

1. 映射: 首先要定义数字到字母的映射（类似电话按键），比如 '2' 对应 'abc'，'3' 对应 'def'，以此类推。

2. 递归探索: 从第一个数字开始，选择其对应的一个字母，然后递归地处理下一个数字，直到处理完所有的数字。

3. 组合生成: 每次递归时，将当前选择的字母加入到当前组合中。如果当前组合的长度等于 digits 的长度，表示生成了一个完整的组合，将其加入到结果集中。

4. 回溯: 如果当前组合未完成（即还未处理完所有的数字），则递归处理下一个数字的字母选择。完成后，回溯到上一个状态，继续尝试其他可能的字母组合。

5. 终止条件: 当 digits 为空时，返回空列表；当遍历完所有数字时，递归终止。

上代码：

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        // 定义数字到字母的映射
        vector<string> mapping = {
            "",     // '0' 无映射
            "",     // '1' 无映射
            "abc",  // '2' 映射到 'abc'
            "def",  // '3' 映射到 'def'
            "ghi",  // '4' 映射到 'ghi'
            "jkl",  // '5' 映射到 'jkl'
            "mno",  // '6' 映射到 'mno'
            "pqrs", // '7' 映射到 'pqrs'
            "tuv",  // '8' 映射到 'tuv'
            "wxyz"  // '9' 映射到 'wxyz'
        };
        
        vector<string> result; // 保存所有组合的结果
        
        // 如果输入为空，直接返回空列表
        if (digits.empty()) return result;
        
        string currentCombination; // 当前组合
        backtrack(result, mapping, digits, currentCombination, 0); // 从第0个数字开始
        return result;
    }
    
private:
    void backtrack(vector<string>& result, const vector<string>& mapping, const string& digits, string& currentCombination, int index) {
        // 如果当前组合的长度等于数字字符串的长度，将其添加到结果中
        if (index == digits.size()) {
            result.push_back(currentCombination);
            return;
        }
        
        // 取得当前数字对应的字母串
        string letters = mapping[digits[index] - '0'];
        
        // 遍历当前数字对应的所有字母
        for (char letter : letters) {
            currentCombination.push_back(letter); // 将当前字母加入到当前组合
            backtrack(result, mapping, digits, currentCombination, index + 1); // 递归处理下一个数字
            currentCombination.pop_back(); // 回溯，移除最后一个字母
        }
    }
};