17. 电话号码的字母组合

百里守约学编程

于 2024-10-01 23:03:13 发布

阅读量391

点赞数 7

分类专栏： # 回溯算法文章标签： leetcode golang 算法

本文链接：https://blog.csdn.net/YouMing_Li/article/details/142675524

版权

回溯算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

17. 电话号码的字母组合
思路
总结

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’] 的一个数字。

思路

从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了。

如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环…

大家应该感觉出和77.组合 遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。

理解本题后，要解决如下三个问题：

数字和字母如何映射
两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来
输入1 * #按键等等异常情况(题目提示表示只会输入2-9，不会输入1 * #，但是要有考虑异常的意识）

数字和字母如何映射
可以使用map或者定义一个二维切片，例如：map:map[byte]string，切片：[]string，来做映射，我这里定义一个map，代码如下：

m := map[byte]string{
        '2':"abc",
        '3':"def",
        '4':"ghi",
        '5':"jkl",
        '6':"mno",
        '7':"pqrs",
        '8':"tuv",
        '9':"wxyz",
    }

如果定义成切片，则为如下形式

s :=[]string {
    "", // 0
    "", // 1
    "abc", // 2
    "def", // 3
    "ghi", // 4
    "jkl", // 5
    "mno", // 6
    "pqrs", // 7
    "tuv", // 8
    "wxyz", // 9
}

回溯法来解决n个for循环的问题

例如：输入："23"，抽象为树形结构，如图所示：

在这里插入图片描述

图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。

回溯三部曲：

1.确定回溯函数参数
首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组res保存起来，再来看看其他参数，参数肯定是有题目中给的digits string，然后还要有一个参数就是int型的index。

注意这个index可不是 77.组合 和216.组合总和III 中的startIndex了。

这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

代码如下：

func backtracking(digits string,m map[byte]string,res *[]string,path *[]byte,index int) {}

2.确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果index 等于输入的数字个数len(digits)了（本来index就是用来遍历digits的,和它相等还继续遍历的话，都要下标索引越界了）。

然后收集结果，结束本层递归。

代码如下：

if index == len(digits) {
  	*res = append(*res,string(*path))
    return
}

3.确定单层遍历逻辑
首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

然后for循环来处理这个字符集，代码如下：

str := m[digits[index]] // 取数字对应的字符集
for i := 0 ;i < len(str);i++ {
    *path = append(*path,str[i])   // 处理
    backtracking(digits,m,res,path,index + 1) // 递归，注意index+1，下层递归要处理下一个数字了
    *path = (*path)[0:len(*path) - 1] // 回溯
}

注意这里for循环，可不像是在 77.组合 和216.组合总和III 中从startIndex开始遍历的。

因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而77. 组合和216.组合总和III 都是求同一个集合中的组合！

注意：输入1 * #按键等等异常情况

代码中最好考虑这些异常情况，但题目的测试数据中应该没有异常情况的数据，所以我就没有加了。

但是要知道会有这些异常，如果是现场面试中，一定要考虑到！

关键地方都讲完了，按照回溯法模板，不难写出如下Go代码：

版本一

func letterCombinations(digits string) []string {
    if len(digits) == 0 {
        return nil
    }

    m := map[byte]string{
        '2':"abc",
        '3':"def",
        '4':"ghi",
        '5':"jkl",
        '6':"mno",
        '7':"pqrs",
        '8':"tuv",
        '9':"wxyz",
    }
    res := make([]string,0)
    path := make([]byte,0)
    backtracking(digits,m,&res,&path,0)
    return res
}

func backtracking(digits string,m map[byte]string,res *[]string,path *[]byte,index int) {
    if index == len(digits) {
        *res = append(*res,string(*path))
        return
    }
    str := m[digits[index]] // 取数字对应的字符集
    for i := 0 ;i < len(str);i++ {
	    *path = append(*path,str[i])   // 处理
	    backtracking(digits,m,res,path,index + 1) // 递归，注意index+1，下层递归要处理下一个数字了
	    *path = (*path)[0:len(*path) - 1] // 回溯
	}
}

时间复杂度: $O(3^m * 4^n)$ ，其中 m 是对应三个字母的数字个数，n 是对应四个字母的数字个数
空间复杂度: $O(3^m * 4^n)$

一些写法，是把回溯的过程放在递归函数里了，例如如下代码，我可以写成这样：（注意注释中不一样的地方）

版本二

func letterCombinations(digits string) []string {   
    // 典型的深度优先搜索，递归题
    if digits == "" { return []string{}}

    // 建立每个数字与字母的组合关系，方便遍历
    m := map[byte]string{
        '2':"abc",
        '3':"def",
        '4':"ghi",
        '5':"jkl",
        '6':"mno",
        '7':"pqrs",
        '8':"tuv",
        '9':"wxyz",
    }
    
    var res []string
    // res:结果，digits:输入的数字组合，0：当前遍历到输入的第几个数字了，m：数字与字符串映射关系,"":当前的组合
    dfs(&res,digits,0,m,"") 
    return res
}

// 注意res也是值传递，而在下面函数中可能改变指向，故需要传指针进来
// 注意和版本一参数的不同，这里路径cur用的string类型，而非[]byte
func dfs(res *[]string,digits string,index int,m map[byte]string,cur string) {
    // 如果当前遍历的数字已经是最后一个了
    if len(cur) == len(digits) {
        *res = append(*res,cur)  
        return 
    }

    // 假如输入“23”，遍历流程为abc，先取a,然后深入下一个数字3，遍历完所有情况ad,ae,af后，才会回到上一层递归，取数字2中的b,然后才再一次深入下一个数字3
    for i:= 0; i < len(m[digits[index]]);i++{
    	// 注意这里与版本一的不同，这里将回溯隐藏在传参中了，利用了值传递的性质
        dfs(res,digits,index + 1,m,cur + string(m[digits[index]][i]))
    }
}