回溯法(backtracking) 题目整理--------part1

回溯法概念：回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。

回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点

出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过

对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来

求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。

概念：http://www.cnblogs.com/jiangchen/p/5393849.html

1. Combination Sum

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

• All numbers (including target) will be positive integers.
• The solution set must not contain duplicate combinations.

 

For example, given candidate set [2, 3, 6, 7] and target 7, 
A solution set is: 

[
  [7],
  [2, 2, 3]
]

刚做的时候的思路：

用for循环+ 递归的方式求解

　　for 循环套在外层，表示遍历数组的第i个数字

　　内层递归表示结果list里的第i个数字（比如第一层递归是寻找list里的第一个数字）

归纳：其实这就是回溯法做的一个dfs，找到第一个节点，然后再找第二个节点，当固定第一个节点的所有解找到后，再换另外个点做为第一个节点。

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        int size = candidates.length;
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        helper (res, list, candidates, target, 0);
        return res;
    }
    private static void helper(List<List<Integer>> res,List<Integer> list, int[] candidates, int target, int pos) {
        if (target == 0) {
            res.add(new ArrayList<Integer>(list));
            return;

        } 
       
        if (target < 0) {
            return;
        }
        int prev = -1;
        for (int i = pos; i < candidates.length; i++) {
            if(prev == candidates[i]) {
                continue;
            }
            list.add(candidates[i]);
            helper(res, list, candidates, target - candidates[i], i);
            prev = candidates[i];
            list.remove(list.size() - 1);
        }
    }
}

 ---------------我是分割线--------------------------------------

Combination Sum 2 

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Note:

• All numbers (including target) will be positive integers.
• The solution set must not contain duplicate combinations.

 

For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8, 
A solution set is: 

[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

这个题目要注意下面的错误情况

用递归寻找第一个元素时，如果之前的结果里已经把1当作第一个元素，然后pop出去了，那么下次的1再想做为第一个元素的话就直接continue，这样就避免了2个[1,2,5]的情况，也就是说，在for循环里面不允许有相同的元素！只有第一次出现才做为valid

public class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        int size = candidates.length;
        Arrays.sort(candidates);
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        helper (res, list, candidates, target, 0);
        return res;
    }
    private static void helper(List<List<Integer>> res,List<Integer> list, int[] candidates, int target, int pos) {
        if (target == 0) {
            res.add(new ArrayList<Integer>(list));
            return;

        } 
        if (target < 0) {
            return;
        }
        int prev = -1;
        for (int i = pos; i < candidates.length; i++) {
            if (candidates[i] > target) {
                break;
            }
            
            if (prev != -1 && prev == candidates[i]) {
                continue;
            }
            
            if (candidates[i] != -1) {
                list.add(candidates[i]);
                helper(res, list, candidates, target - candidates[i], i + 1);
                prev = candidates[i];
                list.remove(list.size() - 1);
            }
        }
    }
}

 ---------------我是分割线--------------------------------------

 

Combination Sum 3

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Example 1:

Input: k = 3, n = 7

Output:

[[1,2,4]]

Example 2:

Input: k = 3, n = 9

Output:

[[1,2,6], [1,3,5], [2,3,4]]

public class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        helper (res, list, k, n, 1);
        return res;
    }
    private static void helper(List<List<Integer>> res,List<Integer> list, int k, int n, int current) {
        if (n == 0 && list.size() == k) {
            res.add(new ArrayList<Integer>(list));
            return;

        } 
        if (list.size() == k || n < 0) {
            return;
        }
        
      
        for (int i = current; i < 10; i++) {
            list.add(i);
            helper(res, list, k, n - i, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

相当于[1,2,3,4,5,6,7,8,9] 的数组，然后增加了k的控制条件

 

 ---------------我是分割线--------------------------------------

 

 Combination Sum IV

 

Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.

Example:

nums = [1, 2, 3]
target = 4

The possible combination ways are:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

Note that different sequences are counted as different combinations.

Therefore the output is 7.

 

Follow up:
What if negative numbers are allowed in the given array?
How does it change the problem?
What limitation we need to add to the question to allow negative numbers?

 

巨坑，只需要返回结果个数，那么其实是个动态规划的题目，类似于爬楼梯！！！

就他娘的这么简单 = = 

public class Solution {
    public int combinationSum4(int[] nums, int target) {
        int size = nums.length;
        Arrays.sort(nums);
        int[] dp = new int[target + 1];
        dp[0] = 1;
        for (int i = 0; i <= target; i++) {
            for (int temp : nums) {
                if (i + temp > target) {
                    break;
                }
                dp[i + temp] += dp[i];
            }
        }
        return dp[target];
        
    }
}

 

 ---------------我是分割线--------------------------------------

 来一枚简单的

Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

 同样的套路

public class Solution {
    public List<List<Integer>> combine(int n, int k) {
       List<List<Integer>> res = new ArrayList<List<Integer>>();
       List<Integer> path = new ArrayList<Integer>();
       if (n < k) {
            return res;
        }
       helper(res, path, n, k, 1);
       return res;
    }
    private void helper (List<List<Integer>> res, List<Integer> path, int n, int k, int current) {
        if (path.size() == k) {
            res.add(new ArrayList<Integer>(path));
            return;
        }
        for (int i = current; i <= n; i++) {
            path.add(i);
            helper(res, path, n, k, i + 1);
            path.remove(path.size() - 1);
        }
    } 
}

 ---------------我是分割线--------------------------------------

 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:

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

 可以用left，right 分别表示左括号和右括号的个数。 我的解法用了valid的int value， 当左括号时+1，右括号时-1. 确保valid大于0

这个for循环也可以不要，直接用做2次，一次left，一次right来代替

public class Solution {
    public List<String> generateParenthesis(int n) {
        StringBuilder sb = new StringBuilder();
        List<String> res = new ArrayList<String>();
        int valid = 0;
        char[] chars = {'(',')'};
        helper (sb, res, valid, chars, n);
        return res;
    }
    private static void helper(StringBuilder sb, List<String> res, int valid, char[] chars, int n) {
        if (valid < 0) {
            return;
        }
        if (sb.length() == 2*n ) {
            if(valid == 0) {
                res.add(sb.toString());
            }
            return;
        }
        for (char temp : chars) {
            sb.append(temp);
            int tempVal = temp == '(' ?  1 :  - 1;
            valid += tempVal;
            helper (sb, res, valid, chars, n);
            valid -= tempVal;
            sb.deleteCharAt(sb.length() - 1);
        }
    }
}

附上九章的答案，就是这么简洁= = 

public class Solution {
    public ArrayList<String> generateParenthesis(int n) {
        ArrayList<String> result = new ArrayList<String>();
        if (n <= 0) {
            return result;
        }
        helper(result, "", n, n);
        return result;
    }
    
    public void helper(ArrayList<String> result,
                       String paren, // current paren
                       int left,     // how many left paren we need to add
                       int right) {  // how many right paren we need to add
        if (left == 0 && right == 0) {
            result.add(paren);
            return;
        }

        if (left > 0) {
            helper(result, paren + "(", left - 1, right);
        }
        
        if (right > 0 && left < right) {
            helper(result, paren + ")", left, right - 1);
        }
    }
}

模仿九章的版本

public class Solution {
    /**
     * @param n n pairs
     * @return All combinations of well-formed parentheses
     */
    public ArrayList<String> generateParenthesis(int n) {
        // Write your code here
        ArrayList<String> res = new ArrayList<String>();
        StringBuilder sb = new StringBuilder();
        int left = 0, right = 0;
        helper (res, sb , n, left, right);
        return res;
    }
    private static void helper(List<String> res, StringBuilder sb, int n, int left, int right) {
        if (sb.length() == 2 * n) {
            if (left == right) {
                res.add(sb.toString());
            }
            return;
        }
        if (left >= right) {
            sb.append('(');
            helper(res, sb, n, left + 1, right);
            sb.deleteCharAt(sb.length() - 1);
        }
        if (left > right) {
            sb.append(')');
            helper(res, sb, n, left, right + 1);
            sb.deleteCharAt(sb.length() - 1);

        }
    }
}

 

 

 

 ---------------我是分割线--------------------------------------

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

public class Solution {
    public List<String> letterCombinations(String digits) {
        StringBuilder sb = new StringBuilder();
        List<String> res = new ArrayList<String>();
        if (digits == null || digits.length() == 0) {
            return res;
        }
        HashMap<Character, String> map = new HashMap<Character, String>();
        map.put ('2', "abc");
        map.put ('3', "def");
        map.put ('4', "ghi");
        map.put ('5', "jkl");
        map.put ('6', "mno");
        map.put ('7', "pqrs");
        map.put ('8', "tuv");
        map.put ('9', "wxyz");
        helper (digits, map, sb, res, 0);
        return res;
    }
    private static void helper (String digits, HashMap<Character, String> map, StringBuilder sb, List<String> res, int current) {
        if (sb.length() == digits.length()) {
            res.add(sb.toString());
            return;
        }
        String temp = map.get(digits.charAt(current));
        for (int i = 0; i < temp.length(); i++) {
            sb.append(temp.charAt(i));
            helper (digits, map, sb, res, current + 1);
            sb.deleteCharAt(sb.length() - 1);
        }
    }
}