回溯算法part2 | ● 216.组合总和III ● 17.电话号码的字母组合

---

216.组合总和III

216.组合总和III

思路

回溯算法，从九个数中选k个数，注意回溯和剪枝。

思路代码

func combinationSum3(k int, n int) [][]int {
    res:=[][]int{}
    path:=[]int{}
    sum:=0
    var backtrack func(startindex int)
    backtrack = func(startindex int){
        if sum>n{
            return
        }
        if len(path)==k{
            if sum==n{
                temp:=make([]int,k)
                copy(temp,path)
                res=append(res,temp)
            }           
            return
        }
        for i:=startindex;i<=9-(k-len(path))+1;i++{
            path=append(path,i)
            sum+=i
            backtrack(i+1)
            path=path[:len(path)-1]
            sum-=i
        }
    }
    backtrack(1)
    return res
}

官方题解

确定递归函数参数
和77. 组合 (opens new window)一样，依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。

这里我依然定义path 和 result为全局变量。

至于为什么取名为path？从上面树形结构中，可以看出，结果其实就是一条根节点到叶子节点的路径。

vector<vector> result; // 存放结果集
vector path; // 符合条件的结果
接下来还需要如下参数：

targetSum（int）目标和，也就是题目中的n。
k（int）就是题目中要求k个数的集合。
sum（int）为已经收集的元素的总和，也就是path里元素的总和。
startIndex（int）为下一层for循环搜索的起始位置。
所以代码如下：

vector<vector> result;
vector path;
void backtracking(int targetSum, int k, int sum, int startIndex)
其实这里sum这个参数也可以省略，每次targetSum减去选取的元素数值，然后判断如果targetSum为0了，说明收集到符合条件的结果了，我这里为了直观便于理解，还是加一个sum参数。

还要强调一下，回溯法中递归函数参数很难一次性确定下来，一般先写逻辑，需要啥参数了，填什么参数。

确定终止条件
什么时候终止呢？

在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。

所以如果path.size() 和 k相等了，就终止。

如果此时path里收集到的元素和（sum） 和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。

所以 终止代码如下：

if (path.size() == k) {
if (sum == targetSum) result.push_back(path);
return; // 如果path.size() == k 但sum != targetSum 直接返回
}
单层搜索过程
本题和77. 组合 (opens new window)区别之一就是集合固定的就是9个数[1,…,9]，所以for循环固定i<=9

如图： 216.组合总和III

处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。

代码如下：

for (int i = startIndex; i <= 9; i++) {
sum += i;
path.push_back(i);
backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
sum -= i; // 回溯
path.pop_back(); // 回溯
}
别忘了处理过程 和 回溯过程是一一对应的，处理有加，回溯就要有减！

代码

var (
    res [][]int
    path  []int
)
func combinationSum3(k int, n int) [][]int {
    res, path = make([][]int, 0), make([]int, 0, k)
    dfs(k, n, 1, 0)
    return res
}

func dfs(k, n int, start int, sum int) {
    if len(path) == k {
        if sum == n {
            tmp := make([]int, k)
            copy(tmp, path)
            res = append(res, tmp)
        }
        return
    }
    for i := start; i <= 9; i++ {
        if sum + i > n || 9-i+1 < k-len(path) {
            break
        }
        path = append(path, i)
        dfs(k, n, i+1, sum+i)
        path = path[:len(path)-1]
    }
}

---

17.电话号码的字母组合

17.电话号码的字母组合

思路

数组模拟字典保存数字和字符串之间的映射。然后递归回溯解决。

思路代码

func letterCombinations(digits string) []string {
    res:=[]string{}
    path:=[]byte{}
    imap:=[]string{"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}
    if len(digits)==0{
        return res
    }
    var backtrack func(startindex int)
    backtrack=func(startindex int){
        if len(path)==len(digits){
            res=append(res,string(path))
            return
        }
        ns:=digits[startindex]
        ni,_:=strconv.Atoi(string(ns))
        for i:=0;i<len(imap[ni]);i++{
            path=append(path,imap[ni][i])
            backtrack(startindex+1)
            path=path[:len(path)-1]
        }
    }
    backtrack(0)
    return res
}

困难

这里的startindex指的是digits字符串中选取的位置，要思考清楚startindex的语义。
startindex其实更像index，回溯算法中如果多个互不影响组合取组合，不需要startindex
本题还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？

我举过例子，如果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)。

如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合(opens new window)

注意以上我只是说求组合的情况，如果是排列问题，又是另一套分析的套路，后面我再讲解排列的时候就重点介绍。

---

今日收获

对递归回溯中剪枝的原理，startindex表示至多开始的位置。
针对不同题目要求，startindex有不同的使用方法，结合题目设计单层递归的for循环。