LeetCode-Generate Parentheses & Letter Combinations of a Phone Number

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

"((()))", "(()())", "(())()", "()(())", "()()()"

回溯法，自己的解答

public List<String> generateParenthesis(int n) {
List<String> list = new ArrayList<String>();
dfs(list, new LinkedList<Character>(), new StringBuilder(), n, 0);
return list;
}
private void dfs(List<String> list, LinkedList<Character> stack, StringBuilder sb, int n, int cnt) {
if (cnt > n) return;
else if (cnt == n && stack.isEmpty()) {
list.add(new String(sb.toString()));
}
StringBuilder temp = new StringBuilder(sb);
LinkedList<Character> stack1 = new LinkedList<Character>(stack);
if (cnt < n) {
sb.append('(');
stack.push('(');
dfs(list, stack, sb, n, cnt+1);
}
if (!stack1.isEmpty() && stack1.peek() == '(') {
temp.append(')');
stack1.pop();
dfs(list, stack1, temp, n, cnt);
}
}

在cc150看到的解法：

public List<String> generateParenthesis(int n) {
List<String> list = new ArrayList<String>();
dfs(list, n, n, new char[n*2], 0);
return list;
}
private void dfs(List<String> list, int left, int right, char[] str, int index) {
if (left < 0 || right < left) return;
if (left == 0 && right == 0) {
list.add(new String(str));
return;
}
if (left > 0) {
str[index] = '(';
dfs(list, left-1, right, str, index+1);
}
if (right > left) {
str[index] = ')';
dfs(list, left, right-1, str, index+1);
}
}

比对下两者的不同：

我用了一个栈，主要受开始学数据结构的影响，自然而然想到用栈了，其实下面的一道题感觉实在用left, right两个指针模拟栈。

用了一个StringBuilder，而下面用了一个char数组，究其原因还是因为这个长度是一定的，肯定是一定的。

对比一道题的多种解题方法还是可以收获很多的，多品味一下！

根据这道题，可以同样解下面这道题。

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.

private String[] table = {" ", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
public List<String> letterCombinations(String digits) {
List<String> list = new ArrayList<String>();
if (digits == null || digits.length() == 0) return list;
char[] str = digits.toCharArray();
dfs(list, str, new char[digits.length()], 0);
return list;
}
private void dfs(List<String> list, char[] str, char[] ret, int index) {
if (index == str.length) {
list.add(new String(ret));
return;
}
for (char c : table[str[index]-'0'].toCharArray()) {
ret[index] = c;
dfs(list, str, ret, index+1);
}
}

感觉用一个数组比StringBuffer好多了，因为可以减少回溯的那个步骤。