leetcode17:Letter Combinations of a Phone Number

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"].

这个题的思想并不难，难得是实现，在我的解法中困难点在于根据传入的数字字符串的长度，如何动态的实现for循环的次数，我用的是递归。解题的思路很简单，将数字和对应的字母存入map中，数字作为key，字母作为value，根据传入的数字字符串，提取相应的value，循环的进行组合。

package leetcode;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class leet17 {
	
//	Map<Character,char[]> map = new HashMap<Character,char[]>();
//	{
//		
//		map.put('1', new char[]{});
//		map.put('2',new char[]{'a','b','c'});
//		map.put('3', new char[]{'d','e','f'});
//		map.put('4',new char[]{'g','h','i'});
//		map.put('5',new char[]{'j','k','l'});
//		map.put('6',new char[]{'m','n','o'});
//		map.put('7', new char[]{'p','q','r','s'});
//		map.put('8', new char[]{'t','u','v'});
//		map.put('9', new char[]{'w','x','y','z'});
//		map.put('0', new char[]{});
//		
//	}
	
	Map<Character,ArrayList<String>> map = new HashMap<Character,ArrayList<String>>();
	{
		/**
		 * 初始化映射
		 */
		ArrayList<String> list = new ArrayList<String>();
		list.add("");
		map.put('1', list);//存储成ArrayList的原因是由于后面递归方便一点
		
		list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		map.put('2',list);
		
		list = new ArrayList<String>();
		list.add("d");
		list.add("e");
		list.add("f");
		map.put('3', list);
		
		list = new ArrayList<String>();
		list.add("g");
		list.add("h");
		list.add("i");
		map.put('4',list);
		
		list = new ArrayList<String>();
		list.add("j");
		list.add("k");
		list.add("l");
		map.put('5',list);
		
		list = new ArrayList<String>();
		list.add("m");
		list.add("n");
		list.add("o");
		map.put('6',list);
		
		list = new ArrayList<String>();
		list.add("p");
		list.add("q");
		list.add("r");
		list.add("s");
		map.put('7', list);
		
		list = new ArrayList<String>();
		list.add("t");
		list.add("u");
		list.add("v");
		map.put('8', list);
		
		list = new ArrayList<String>();
		list.add("w");
		list.add("x");
		list.add("y");
		list.add("z");
		map.put('9', list);
		
		list = new ArrayList<String>();
		list.add("");
		map.put('0', list);
		
	}
	public static void main(String[] args) {
		
		leet17 lee = new leet17();
		List<String> result = lee.letterCombinations("23");
		System.out.println(result.toString());
	}
	
	public List<String> letterCombinations(String digits) {
		
		//存储digits中每一个数字对应的List，因为映射中每一个数字对应的就是一个ArrayList 
		List<List<String>> temp = new ArrayList<List<String>>();
		 for(int i = 0;i < digits.length();i++){//循环的获取每一个数字对应的List
			 
			 temp.add(map.get(digits.charAt(i)));
		 }
		//获取temp的大小，即就是digits中有几个数字
		 int level = temp.size();
		//递归的进行组合，因为有几个数字就需要进行几次循环，这个需要动态的进行
		 List<String> result = Recursive(temp,level);
		return result;
	        
	}
	
	/**
	 * 
	 * 因为事先不知道需要进行几次for循环，所以需要用递归的方法动态的根据digits中的数字的个数决定循环的次数
	 * 当level等于1时，表示temp中的组合结束只剩一个List在其中了。所以返回结果
	 * 
	 * 递归的方法是先组合temp中的第一和第二个list，然后删除第一个第二个list，将组合后的list添加进去，
	 * level减1，重新进行递归，直到temp中只剩一个list表示结束
	 * 
	 */
	public static List<String> Recursive(List<List<String>> temp,int level){
		
		if(level == 1){			
			return temp.get(0);
		}else{
			List<String> str1 = temp.get(0);//temp中的第一个list
			List<String> str2 = temp.get(1);//temp中的第二个list
			
			//前面两个list组合后的list,使用List的原因是组合后的数组大小会增大所以，
			//ArrayList可以适应数组的动态增长，方便不用事先指定数组大小
			List<String> str = new ArrayList<String>();
													   
			for(int i = 0;i < str1.size();i++){
				for(int j = 0;j < str2.size();j++){
					str.add(str1.get(i)+str2.get(j));
				}
			}
			temp.remove(0);//移除第一个list
			temp.remove(0);//移除第二个list
			temp.add(str);//添加组合后的list
			Recursive(temp,level - 1);//进行递归
		}
		return temp.get(0);				
	}
}