代码随想录day25｜216.组合总和III｜17.电话号码的字母组合｜Golang
代码随想录day25
好
目录
216.组合总和III
17.电话号码的字母组合
216.组合总和III
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
只使用数字1到9
每个数字 最多使用一次
输入: k = 3, n = 7
输出: [[1,2,4]]
解释: 1 + 2 + 4 = 7 没有其他符合的组合了。
本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。本题宽相当于1、2、3、4、5、6、7、8、9。 深度相当于k
找出在宽度内深度为k且之和等于n的组合。
例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9] 中求 个数(k) = 2, 和(n)= 4的组合。
图中，可以看出，只有最后取到集合（1，3）和为4 符合条件。
回溯三部曲来咯
1、确定递归参数：
/*
1、确定递归函数参数
targetSum也就是题目要求的n
k也就是题目要求的k个数的集合
path_sum 也就是path上存放的元素的和
startindex为下一层for循环搜索的起始位置
*/
var path []int
var result [][]int
func backtrack(target, k, path_sum, startindex int){
}
//还要强调一下，回溯法中递归函数参数很难一次性确定下来，一般先写逻辑，需要啥参数了，填什么参数。2、确定终止条件：
/*
2、确定终止条件
终止条件就是len(path) == k，因为再往下没意义的。
如果此时path里面收集到的元素和path_sum == targetSum了（题目要求的n），那么就把path放进result里面。
*/
if len(path) == k {
if path_sum == targetSum {
tmp := make([]int,k)
copy(tmp, path)
result = append(result, tmp)
return
}
}3、单层搜索过程：
/*
3、单层搜索过程
本题和77组合的区别之一就是集合固定为9个数字[1,2,3,4,5,6,7,8,9]，所以for循环<=9。
处理过程就是path收集选取的元素，相当于树形结构的边，path_sum用来统计path里面的元素之和。
*/
for i:=startindex;i<=9;i++{
path = append(path,i)
path_sum += i
backtrack(targetSum, k, path_sum, i+1)
path_sum -=i //记得回溯撤销
path = path[:len(path)-1] //记得回溯撤销
}
//别忘了处理过程 和 回溯过程是一一对应的，处理有加，回溯就要有减！
不难写出如下Go代码：
//总的代码，未剪枝前
var path []int
var result [][]int
func combinationSum3(k int, n int) [][]int {
result = [][]int{}
backtrack(n,k,0, 1)
return result
}
func backtrack(target_sum, k, path_sum, startIndex int) {
if len(path) == k {
if path_sum == target_sum {
temp := make([]int, k)
copy(temp, path)
result = append(result, temp)
return
}
}
for i:=startIndex;i<=9;i++{
path = append(path, i)
path_sum += i
backtrack(target_sum, k, path_sum,i+1)
path_sum -= i
path = path[:len(path)-1]
}
}
// targetSum：目标和，也就是题目中的n。
// k：题目中要求k个数的集合。
// sum：已经收集的元素的总和，也就是path里元素的总和。
// startIndex：下一层for循环搜索的起始位置。剪枝
这道题目，剪枝操作其实是很容易想到了，想必大家看上面的树形图的时候已经想到了。
如图：
已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。
那么剪枝的地方一定是在递归终止的地方剪，剪枝代码如下：
if path_sum > targetSum {
return
}和回溯算法：组合问题再剪剪枝
一样，for循环的范围也可以剪枝，i <= 9 - (k - path.size()) + 1就可以了。
最后Go代码如下：
//总的代码
//总的代码
var path []int
var result [][]int
func combinationSum3(k int, n int) [][]int {
result = [][]int{}
backtrack(n,k,0, 1)
return result
}
func backtrack(target_sum, k, path_sum, startIndex int) {
if path_sum > target_sum {
return
}
if len(path) == k {
if path_sum == target_sum {
temp := make([]int, k)
copy(temp, path)
result = append(result, temp)
return
}
}
for i:=startIndex;i<=9-(k-len(path))+1;i++{
path = append(path, i)
path_sum += i
backtrack(target_sum, k, path_sum,i+1)
path_sum -= i
path = path[:len(path)-1]
}
}
// targetSum：目标和，也就是题目中的n。
// k：题目中要求k个数的集合。
// sum：已经收集的元素的总和，也就是path里元素的总和。
// startIndex：下一层for循环搜索的起始位置。开篇就介绍了本题与77.组合的区别，相对来说加了元素总和的限制，如果做完77.组合
再做本题在合适不过。
分析完区别，依然把问题抽象为树形结构，按照回溯三部曲进行讲解，最后给出剪枝的优化。相信做完本题，大家对组合问题应该有初步了解了。
17.电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。
示例 2：
输入：digits = ""
输出：[]
示例 3：
输入：digits = "2"
输出：["a","b","c"]
从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了。
如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环.......
应该感觉出和[77.组合遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。
理解本题后，要解决如下三个问题：
- 数字和字母如何映射
- 两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来
- 输入1 * #按键等等异常情况
//1.数字和字母如何映射
可以使用map或者定义一个数组来映射。这里用数组。
yingshe := []string{"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}利用回溯法来解决n个for循环的问题。例如输入：“23”，抽象为树形结构，如图所示：
先按2（abc），再按3（def）。 长度为2哦
图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
回溯三部曲！
1、确定回溯函数参数：
//回溯三部曲
1、确定回溯函数参数
首先需要一个path来收集叶子节点的结果，然后用result把所有path保存起来。
再来看看参数，参数指定是有题目中给的string digits，也就是给定的数字，只不过他是给的string类型的数字，反正给的数字有对应的字符串。然后需要用deep_index，用来记录遍历第几个数了，也就是遍历深度，也就是遍历题目要求的digits(字符串的数字)。
var path []int
var result [][]int
func backtracking(digits string, deep_index int, yingshe []string, path []byte ) {
}2、递归终止条件：
2、确定终止条件
例如输入用例“23”，共两个数，那么根节点往下递归两层就可以了。叶子节点path就是要收集的结果集。那么终止条件就是如果deep_index == len(digits)输入的数字个数。就可以了。然后收集结果，结束本层递归。
if deep_index == len(digits) {
tmp := make([]int,len(digits))
copy(tmp, path)
result = append(result, tmp)
return
}3、确定单层递归逻辑：
3、确定单层遍历逻辑
首先要取index指向的数字，并找到对应的字符集（数字对应的字母集），然后用for循环来处理这个数据集。
digit = digits[index] - '0'
letters := yingshe[digit] //单个数字对应的字母集
for i:=0;所以总的代码如下：
var result []string
var path []byte
func letterCombinations(digits string) []string {
result = []string{}
if len(digits) == 0 {
return result
}
yingshe := []string{"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}
backtracking(digits, 0, yingshe, path )
return result
}
func backtracking(digits string, deep_index int, yingshe []string, path []byte ) {
if deep_index == len(digits) {
result = append(result, string(path))
return
}
digit := digits[deep_index] - '0' // 例如字符'2'的ascii码是50，字符'0'的ascii码是48。不减会越界的导致panic的。
letters := yingshe[digit]
for i := 0; i < len(letters); i++ {
path = append(path, letters[i])
backtracking(digits, deep_index+1, yingshe, path)
path = path[:len(path) - 1]
}
}以上