Python算法题集_电话号码的字母组合

本文为Python算法题集之一的代码示例

题17：电话号码的字母组合

1. 示例说明

• 给定一个仅包含数字 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'] 的一个数字。

---

2. 题目解析

- 题意分解

1. 本题是计算多个集合之间的乘积问题，即每个集合抽取一个元素最终能形成的组合集数量
2. 基本的设计思路是回溯法，使用递归来统计组合集
3. 回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法。

- 优化思路

1. 通常优化：减少循环层次

2. 通常优化：增加分支，减少计算集

3. 通常优化：采用内置算法来提升计算速度

4. 分析题目特点，分析最优解

   1. 每加一个元素，添加的组合等于旧元素全排列集合与新元素各排列一次，以此递归

   2. 可以考虑用高效迭代模块单元itertools

---

- 测量工具

• 本地化测试说明：LeetCode网站测试运行时数据波动很大【可把页面视为功能测试】，因此需要本地化测试解决数据波动问题
• CheckFuncPerf（本地化函数用时和内存占用测试模块）已上传到CSDN，地址：Python算法题集_检测函数用时和内存占用的模块
• 本题本地化超时测试用例自己生成，详见章节【最优算法】，代码文件包含在【相关资源】中

---

3. 代码展开

1) 标准求解【字典+堆栈回溯】

用字典结构保存数字和字符映射关系，使用堆栈结构来完成回溯

页面功能测试，性能良好，超过79%

import CheckFuncPerf as cfp

class Solution:
 def letterCombinations_base(self, digits):
     if not digits:
         return []
     phoneMap = {
         '2': 'abc', '3': 'def', '4': 'ghi',
         '5': 'jkl', '6': 'mno', '7': 'pqrs',
         '8': 'tuv', '9': 'wxyz',
     }
     def backtrack(index):
         if index == len(digits):
             combinations.append(''.join(combination))
         else:
             digit = digits[index]
             for achar in phoneMap[digit]:
                 combination.append(achar)
                 backtrack(index + 1)
                 combination.pop()
     combination, combinations = [], []
     backtrack(0)
     return combinations

aSolution = Solution()
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_base, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))

# 运行结果
函数 letterCombinations_base 的运行时间为 11202.09 ms；内存使用量为 1078116.00 KB 执行结果 = 15116544

2) 改进版一【字典+变量回溯】

用字典结构保存数字和字符映射关系，使用在递归参数中传递变量【非引用传递】的方式来完成回溯

页面功能测试，性能良好，超越82%

import CheckFuncPerf as cfp

class Solution:
 def letterCombinations_ext1(self, digits):
     result = []
     if not digits:
         return result
     phoneMap = {
         '2': 'abc', '3': 'def', '4': 'ghi',
         '5': 'jkl', '6': 'mno', '7': 'pqrs',
         '8': 'tuv', '9': 'wxyz',
     }
     def backtrack(combination, nextdigit):
         if len(nextdigit) == 0:
             result.append(combination)
         else:
             for achar in phoneMap[nextdigit[0]]:
                 backtrack(combination + achar, nextdigit[1:])
     backtrack('', digits)
     return result

aSolution = Solution()
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_ext1, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))

# 运行结果
函数 letterCombinations_ext1 的运行时间为 8637.52 ms；内存使用量为 1077632.00 KB 执行结果 = 15116544

3) 改进版二【列表+变量回溯】

通过用数字下标访问方式，用列表保存数字和字符映射关系，使用在递归参数中传递变量【非引用传递】的方式来完成回溯

页面功能测试，马马虎虎，超过55%

import CheckFuncPerf as cfp

class Solution:
 def letterCombinations_ext2(self, digits):
     result = []
     ilen = len(digits)
     if ilen == 0:
         return result
     phoneMap = ['', '', 'abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']
     path = ''
     def backtrack(isize, path):
         if isize == ilen:
             result.append(path)
         else:
             for achar in phoneMap[int(digits[isize])]:
                 backtrack(isize + 1, path + achar)
     backtrack(0, path)
     return result

aSolution = Solution()
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_ext2, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))

# 运行结果
函数 letterCombinations_ext2 的运行时间为 7977.90 ms；内存使用量为 1077740.00 KB 执行结果 = 15116544

4) 改进版三【字典+高效迭代模块】

用字典结构保存数字和字符映射关系，使用高效迭代模块itertool的迭代器，直接一行生成组合集

页面功能测试，马马虎虎，超过32%

import CheckFuncPerf as cfp

class Solution:
 def letterCombinations_ext3(self, digits):
     if not digits:
         return list()
     phoneMap = {
         '2': 'abc', '3': 'def', '4': 'ghi',
         '5': 'jkl', '6': 'mno', '7': 'pqrs',
         '8': 'tuv', '9': 'wxyz',
     }
     groups = (phoneMap[digit] for digit in digits)
     import itertools
     return [''.join(combination) for combination in itertools.product(*groups)]
 
aSolution = Solution()
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_ext3, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))

# 运行结果
函数 letterCombinations_ext3 的运行时间为 3883.88 ms；内存使用量为 1077548.00 KB 执行结果 = 15116544

---

4. 最优算法

根据本地日志分析，最优算法为第4种方式【字典+高效迭代模块】permute_ext3

本题测试数据，似乎能推出以下结论：

1. list的pop()函数性能弱于切片操作
2. itertool模块应该是用C等语言实现，效率远高于Python代码逐行实现

import random
phonenums = ''.join([str(random.randint(2, 9)) for x in range(14)])
aSolution = Solution()
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_base, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_ext1, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_ext2, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))
result = cfp.getTimeMemoryStr(aSolution.letterCombinations_ext3, phonenums)
print(result['msg'], '执行结果 = {}'.format(len(result['result'])))

# 算法本地速度实测比较
函数 letterCombinations_base 的运行时间为 11202.09 ms；内存使用量为 1078116.00 KB 执行结果 = 15116544
函数 letterCombinations_ext1 的运行时间为 8637.52 ms；内存使用量为 1077632.00 KB 执行结果 = 15116544
函数 letterCombinations_ext2 的运行时间为 7977.90 ms；内存使用量为 1077740.00 KB 执行结果 = 15116544
函数 letterCombinations_ext3 的运行时间为 3883.88 ms；内存使用量为 1077548.00 KB 执行结果 = 15116544

---

5. 相关资源

本文代码已上传到CSDN，地址：Python算法题源代码_LeetCode(力扣)_电话号码的字母组合

一日练，一日功，一日不练十日空

may the odds be ever in your favor ~