day22 力扣77.组合 力扣216.组合总和III 力扣17.电话号码的字母组合
组合
给定两个整数
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 <= 201 <= k <= n
回溯算法的第一题，我们按照回溯三部曲进行。
第一步：确定返回值和参数，因为我们只需要把每次符合条件的path数组加入到result的二维数组中即可，那么我们的返回值是void就可以；参数的话，我么除了必须要加入的n,k以外，还要加入一个startIndex值，这个值帮我们确定每一次for循环往path加值的开始位置。
第二步：确定终止条件，也就是什么时候path数组会符合条件呢？也就是path的大小等于k的时候，这时候我们把path加在result里，返回即可。
第三步：单层搜索的过程。也就for循环里面的内容。我们要知道每次这一个for循环里我们要往path里加值直至终止条件，那就要递归；其次还要回溯以保证得到多种结果。
还要注意的是我们的回溯还可以考虑剪枝操作，尽可能减少时间复杂度。
class Solution {
public:
vector> result;
vector path;
void backtracking(int n, int k,int startIndex)
{
if(path.size()==k)
{
result.push_back(path);
return ;
}
for(int i = startIndex;i<=n-(k-path.size())+1;i++)
{
path.push_back(i);
backtracking(n,k,i+1);
path.pop_back();
}
return ;
}
vector> combine(int n, int k) {
backtracking(n,k,1);
return result;
}
}; 组合总和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 <= 91 <= n <= 60
头一回自己做出来一道递归的题，还是很爽的。
依旧是用回溯三部曲分析：
第一步：确定参数和返回值，这个跟上一道题一模一样，不多说。
第二步：确定终止条件，我们先定义一个sum，这个sum记录path中所有元素的和。如果sum==n了，且此时的path的元素个数等于k，那么我们就将path加到result里，return即可。此外我们还有一个终止条件，就是如果sum>n的话，直接返回return。不加这个的话，很可能无限递归下去，最后溢出。
第三步：单层搜索的过程。也就for循环里面的内容。这个相比较上一个题，只需要多加一个对sum的处理就可以，push_back的时候就sum+=i；pop_back的时候就sum-=i。
依旧考虑剪枝操作
class Solution {
public:
int sum = 0;
vector path;
vector> result;
void backtracking(int k, int n,int startIndex)
{
if(sum==n&&path.size()==k)
{
result.push_back(path);
return;
}
if(sum>n)return ;
for(int i = startIndex;i<=9-(k-path.size())+1;i++)
{
path.push_back(i);
sum+=i;
backtracking(k,n,i+1);
path.pop_back();
sum-=i;
}
}
vector> combinationSum3(int k, int n) {
sum = 0;
backtracking(k,n,1);
return result;
}
}; 电话号码的字母组合
给定一个仅包含数字
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 <= 4digits[i]是范围['2', '9']的一个数字。
首先我们可以定义一个string类型的数组去做映射，也可以直接使用哈希表去做。
private:
const string letterMap[10] = {
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
};然后再回溯三部曲分析：
第一步：确定返回值和参数，返回值同上，参数的话，要把digits这个string传入以外，还要传入一个索引值，用来确定此时的位置，以及当前path的大小。
第二步：确定终止条件，也就是index（或path的大小）等于digits的大小时，将path传入result里，return。
第三步：单层搜索的过程。也就for循环里面的内容。在此之前，要从digits里拿出index值，涉及到类型转换的问题。再自定义一个string类型的letters承接index映射的字符串。for的参数从0开始，到letters.size()。在for内就跟以前一样的内容了。
class Solution {
private:
const string letterMap[10] = {
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
};
public:
string path;
vector result;
void backtracking(string digits,int index)
{
if(path.size()==digits.size())
{
result.push_back(path);
return;
}
int digit = digits[index] - '0';
string letters = letterMap[digit];
for(int i = 0;i< letters.size();i++)
{
path.push_back(letters[i]);
backtracking(digits,index+1);
path.pop_back();
}
}
vector letterCombinations(string digits) {
if (digits.size() == 0)
{
return result;
}
backtracking(digits,0);
return result;
}
};