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好多了，因为可以减少回溯的那个步骤。