leetcode17

回溯法，深度优先遍历（DFS）

public class Solution
    {
        int[] x;
        int N;
        string DIGITS;
        Dictionary<char, List<string>> dic = new Dictionary<char, List<string>>();
        List<string> LIST = new List<string>();
        private void BackTrack(int t)
        {
            if (t >= N)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < N; i++)
                {
                    var dkey = DIGITS[i];
                    var temp = dic[dkey][x[i]];
                    sb.Append(temp);
                }
                LIST.Add(sb.ToString());
                return;
            }
            for (int i = 0; i < dic[DIGITS[t]].Count; i++)
            {
                x[t] = i;
                BackTrack(t + 1);
            }
        }
        private void Init()
        {
            dic.Add('2', new List<string> { "a", "b", "c" });
            dic.Add('3', new List<string> { "d", "e", "f" });
            dic.Add('4', new List<string> { "g", "h", "i" });
            dic.Add('5', new List<string> { "j", "k", "l" });
            dic.Add('6', new List<string> { "m", "n", "o" });
            dic.Add('7', new List<string> { "p", "q", "r", "s" });
            dic.Add('8', new List<string> { "t", "u", "v" });
            dic.Add('9', new List<string> { "w", "x", "y", "z" });
        }
        public IList<string> LetterCombinations(string digits)
        {
            var n = digits.Length;
            if (n > 0)
            {
                Init();
                N = n;
                x = new int[n];
                DIGITS = digits;
                BackTrack(0);
            }
            return LIST;
        }
    }

提供一种更直接的思路：

public class Solution {
    public IList<string> LetterCombinations(string digits) {
        var combinations = new List<string>();
        
        if(string.IsNullOrEmpty(digits))
            return combinations;
        
        combinations.Add("");
        foreach(char digit in digits) {
            var next = new List<string>();
            
            foreach(char letter in GetLetters(digit)) {
                foreach(string combo in combinations) {
                    next.Add(combo + letter);
                }
            }
            combinations = next;
        }
        return combinations;
    }
    
    public char[] GetLetters(char digit) {
        switch (digit) {
            case '2':
                return new char[] { 'a', 'b', 'c' };
            case '3':
                return new char[] { 'd', 'e', 'f' };
            case '4':
                return new char[] { 'g', 'h', 'i' };
            case '5':
                return new char[] { 'j', 'k', 'l' };
            case '6':
                return new char[] { 'm', 'n', 'o' };
            case '7':
                return new char[] { 'p', 'q', 'r', 's' };
            case '8':
                return new char[] { 't', 'u', 'v' };
            case '9':
                return new char[] { 'w', 'x', 'y', 'z' };
            default:
                return new char[0];
        }
    }
}

补充一个python的实现：

class Solution:
    def backTrack(self,digits,dic,temp,res,i):
        if i == len(digits):
            res.append(''.join(temp[:]))
            return
        
        key = digits[i]
        li = dic[key]
        for j in range(len(li)):
            temp.append(li[j])
            self.backTrack(digits,dic,temp,res,i+1)
            temp.pop(-1)
        
        
    def letterCombinations(self, digits: 'str') -> 'List[str]':
        n = len(digits)
        if n == 0:
            return []
        res = []
        dic = {'2':['a','b','c'],'3':['d','e','f'],'4':['g','h','i'],
              '5':['j','k','l'],'6':['m','n','o'],'7':['p','q','r','s'],'8':['t','u','v'],'9':['w','x','y','z']}
        self.backTrack(digits,dic,[],res,0)
            
        return res

思路：回溯法。

回溯函数的参数含义：

digits:原字符串，dic:按键字典，temp:字母组合的临时存储，res:最终结果的列表，i:digits的索引。