17. Letter Combinations of a Phone Number && 22. Generate Parentheses && 20. Valid Parentheses

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 String

 

Queue: Add letters to queue, and appending one more to each element in queue.

public class Solution {
    public List<String> letterCombinations(String digits) {
        if(digits.equals(""))
            return new ArrayList<String>();
                
        LinkedList<String> ans = new LinkedList<String>();
        String[] mapping = new String[] {"0", "1", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        ans.add("");
        for(int i =0; i<digits.length();i++){
            int x = Character.getNumericValue(digits.charAt(i));
            while(ans.peek().length()==i){
                String t = ans.remove();
                for(char s : mapping[x].toCharArray())
                    ans.add(t+s);
            }
        }
        return ans;
    }
}

 

Recursive:

public class Solution {
    public List<String> letterCombinations(String digits) {
        if(digits.equals(""))
            return new ArrayList<String>();
            
        HashMap<Character, List<Character>> m = new HashMap<Character, List<Character>>();
        m.put('2', new LinkedList<Character>(){{add('a');add('b');add('c');}});
        m.put('3', new LinkedList<Character>(){{add('d');add('e');add('f');}});
        m.put('4', new LinkedList<Character>(){{add('h');add('i');add('g');}});
        m.put('5', new LinkedList<Character>(){{add('k');add('l');add('j');}});
        m.put('6', new LinkedList<Character>(){{add('n');add('o');add('m');}});
        m.put('7', new LinkedList<Character>(){{add('p');add('q');add('r');add('s');}});
        m.put('8', new LinkedList<Character>(){{add('t');add('u');add('v');}});
        m.put('9', new LinkedList<Character>(){{add('w');add('x');add('y');add('z');}});
        
        return letterCombinations(digits, m);
        
    }
    
    public List<String> letterCombinations(String digits, HashMap<Character, List<Character>> m) {
        if(digits.length() == 1)
        {
            List<String> ret = new LinkedList<String>();
            for(Character c : m.get(digits.charAt(0)))
            {
                    ret.add(c.toString());
            }
            return ret;
        }
        
        List<String> rest = letterCombinations(digits.substring(1,digits.length()),m);
        List<String> ret = new LinkedList<String>();
        for(Character c : m.get(digits.charAt(0)))
        {
            for(String s: rest)
            {
                ret.add(c+s);
            }
        }
        
        return ret;
    }
}

 

22. Generate Parentheses

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:

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

Backtracking String

 

public class Solution {
  public List<String> generateParenthesis(int n) {
    ArrayList<String> results = new ArrayList<>();
    generateParenthesis(results, n, new StringBuilder(), n);
    return results;
  }

  private void generateParenthesis(List<String> results, int remaining, StringBuilder sb, int unmatched) {
    if (remaining == 0 && unmatched == 0) {
      results.add(sb.toString());
      return;
    }

    if (remaining > 0) {
      sb.append("(");
      generateParenthesis(results, remaining - 1, sb, unmatched);
      sb.setLength(sb.length() - 1);
    }

    if (unmatched > remaining) {
      sb.append(")");
      generateParenthesis(results, remaining, sb, unmatched - 1);
      sb.setLength(sb.length() - 1);
    }
  }
}

 

20. Valid Parentheses

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

public class Solution {
    public boolean isValid(String s) {
        if(s == null)
            return true;
        Deque<Character> stack = new LinkedList<Character>();
        for(char cc : s.toCharArray()){
            if(cc=='(' || cc=='[' || cc=='{')
                stack.push(cc);
            if(cc==')')
            {
                if(stack.isEmpty() || stack.peek()!='(')
                    return false;
                stack.pop();
            }
            
            else if(cc==']')
            {
                if(stack.isEmpty() || stack.peek()!='[')
                    return false;
                stack.pop();
            }
            
            else if(cc=='}')
            {
                if(stack.isEmpty() || stack.peek()!='{')
                    return false;
                stack.pop();
            }
        }
        if(stack.isEmpty())
            return true;
        return false;
    }
}