zoukankan      html  css  js  c++  java
  • 17. Letter Combinations of a Phone Number

    题目:

    Given a digit string, return all possible letter combinations that the number could represent.

    A mapping of digit to letters (just like on the telephone buttons) is given below.

    Input:Digit string "23"
    Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
    

    Note:
    Although the above answer is in lexicographical order, your answer could be in any order you want.

    链接:

    题解:

    也是backtracking,跟permutation一类很像。这次是对每个数字对应的字符进行回溯。  Time Complexity ~ O(3n), Space Compelxity - O(n);

    public class Solution {
        public List<String> letterCombinations(String digits) {
            List<String> res = new ArrayList();
            if(digits == null || digits.length() == 0)
                return res;
            StringBuilder sb = new StringBuilder();
            String[] map = {"", "","abc","def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
            dfs(res, sb, digits, map, 0);
            return res;
        }
        
        private void dfs(List<String> res, StringBuilder sb, String digits, String[] map, int pos) {
            if(pos == digits.length()) {
                res.add(sb.toString());
                return;
            }  
            int num = digits.charAt(pos) - '0';
            String str = map[num];
            
            for(int i = 0; i < str.length(); i++) {
                sb.append(str.charAt(i));
                dfs(res, sb, digits, map, pos + 1);
                sb.deleteCharAt(sb.length() - 1);
            }
        }
    }

    二刷:

    比较容易的dfs + backtracking。就是在遍历digits的同时对每个数字可能代表的字符做回溯。也有相应的BFS version,放在reference里

    这里复杂度的计算主要参考了UBC AI课程的lecture notes。假设DFS的 path深度是n,branching factor是m那么DFS的Time Complexity 就是 O(bm), Space Complexity为 O(bm)。 而对相同的图, BFS的Time Complexity也是O(bm), Space Complexity则为 O(bm)。

    When is DFS appropriate? space is restricted solutions tend to occur at the same depth in the tree you know how to order nodes in the list of neighbours so that solutions will be found relatively quickly

    When is DFS inappropriate? some paths have infinite length the graph contains cycles some solutions are very deep, while others are very shallow

    When is BFS appropriate? space is not a problem it’s necessary to find the solution with the fewest arcs although all solutions may not be shallow, at least some are there may be infinite paths

    When is BFS inappropriate? space is limited all solutions tend to be located deep in the tree the branching factor is very large

    Java:


    Time Complexity - O(3n), Space Complexity - O(n)。

    public class Solution {
        public List<String> letterCombinations(String digits) {
            List<String> res = new ArrayList<>();
            if (digits == null || digits.length() == 0) {
                return res;
            }
            char[][] map = new char[10][0];
            map[2] = new char[] {'a', 'b', 'c'};
            map[3] = new char[] {'d', 'e', 'f'};
            map[4] = new char[] {'g', 'h', 'i'};
            map[5] = new char[] {'j', 'k', 'l'};
            map[6] = new char[] {'m', 'n', 'o'};
            map[7] = new char[] {'p', 'q', 'r', 's'};
            map[8] = new char[] {'t', 'u', 'v'};
            map[9] = new char[] {'w', 'x', 'y', 'z'};
            StringBuilder sb = new StringBuilder();
            letterCombinations(res, sb, map, digits, 0);
            return res;
        }
        
        private void letterCombinations(List<String> res, StringBuilder sb, char[][] map, String digits, int pos) {
            if (pos == digits.length()) {
                res.add(sb.toString());
                return;
            }
            int num = digits.charAt(pos) - '0';
            for (int j = 0; j < map[num].length; j++) {
                sb.append(map[num][j]);
                letterCombinations(res, sb, map, digits, pos + 1);
                sb.setLength(sb.length() - 1);
            }
        }
    }

    Python:

    class Solution(object):
        def letterCombinations(self, digits):
            """
            :type digits: str
            :rtype: List[str]
            """
            if not digits:
                return []
            dict = {}
            dict[2] = ['a', 'b', 'c']
            dict[3] = ['d', 'e', 'f']
            dict[4] = ['g', 'h', 'i']
            dict[5] = ['j', 'k', 'l']
            dict[6] = ['m', 'n', 'o']
            dict[7] = ['p', 'q', 'r', 's']
            dict[8] = ['t', 'u', 'v']
            dict[9] = ['w', 'x', 'y', 'z']
            res = []
            list = ''
            self.helper(res, list, dict, digits, 0)
            return res
            
        def helper(self, res, list, dict, digits, pos):
            if pos == len(digits):
                res.append(list)
                return
            num = int(digits[pos])
            for c in dict[num]:
                list += c
                self.helper(res, list, dict, digits, pos + 1)
                list = list[:-1]
            
                
            

      

    三刷:

    Java:

    DFS + Backtracking:

    Time Complexity - O(3n), Space Complexity - O(n)。

    public class Solution {
        public List<String> letterCombinations(String digits) {
            List<String> res = new ArrayList<>();
            if (digits == null || digits.length() == 0) return res;
            String[] map = new String[] {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
            getLetterCombinations(res, new StringBuilder(), map, digits, 0);
            return res;
        }
        
        private void getLetterCombinations(List<String> res, StringBuilder sb, String[] map, String digits, int pos) {
            if (pos == digits.length()) {
                res.add(sb.toString());
                return;
            }
            int index = digits.charAt(pos) - '0';
            String letters = map[index];
            for (int i = 0; i < letters.length(); i++) {
                sb.append(letters.charAt(i));
                getLetterCombinations(res, sb, map, digits, pos + 1);
                sb.setLength(sb.length() - 1);
            }
        }
    }

    BFS:

    解答来自Discuss区的lirensun

    public class Solution {
        public List<String> letterCombinations(String digits) {
            LinkedList<String> res = new LinkedList<>();
            if (digits == null || digits.length() == 0) return res;
            String[] map = new String[] {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
            res.add("");
            for (int i = 0; i < digits.length(); i++) {
                int index = digits.charAt(i) - '0';
                while (res.peek().length() == i) {
                    String t = res.remove();
                    for (char c : map[index].toCharArray()) {
                        res.add(t + c);
                    }
                }
            }
            return res;
        }
    }

    Reference:

    https://www.cs.ubc.ca/~kevinlb/teaching/cs322%20-%202008-9/Lectures/Search3.pdf

    https://leetcode.com/discuss/24431/my-java-solution-with-fifo-queue

  • 相关阅读:
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器解决方案之多方式虚拟直播
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器解决方案之点播分享
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器与EasyDSS流媒体解决方案的不同
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器软件实现的多码率视频点播功能说明
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器解决方案之Windows服务安装
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器解决方案之Nodejs调用bat或sh脚本
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器解决方案之Grunt的使用简介
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器启用https服务申请免费证书
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器软件二次开发接口对接说明示列
    EasyDSS高性能RTMP、HLS(m3u8)、HTTP-FLV、RTSP流媒体服务器和EasyDSS云平台异同
  • 原文地址:https://www.cnblogs.com/yrbbest/p/4433742.html
Copyright © 2011-2022 走看看