回溯法总结

转  http://www.zhimengzhe.com/bianchengjiaocheng/Javabiancheng/257227.html

 

 

1、回溯法

 

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

 

如果需要求所有的解，则需要对每个状态进行搜索。（函数返回值设为void）如果要求存在一个解，那么找到某个解直接返回即可。（函数返回值设为boolean）

 

2、算法框架

回溯法主要分为求所有的解求存在一个解，其代码框架如下所示。

核心把握：

结果收集条件（回溯结束条件）继续进入下一层搜索条件搜索上界下界

//求所有解的算法框架
    public void backtracting(temp){
        if("temp是一个结果"){  //结果收集条件
            加入结果集;
            return;
        }
        for(j=start;j<= end;j++){
            if("不满足加入条件") continue;
            temp.add(a); //加入当前元素
            backtracting(j+1); //继续进行下一步搜索
            temp.remove(a); //回溯的清理工作，把上一步的加入结果删除
        }
    }
    //求存在解的算法框架
    public boolean backtracting(temp){
        if("temp是一个结果"){  //结果收集条件
            加入结果集;
            return true;
        }
        for(j=start;j<= end;j++){
            if("不满足加入条件") continue;
            temp.add(a); //加入当前元素
            if(backtracting(j+1))
                return true; //继续进行下一步搜索
            temp.remove(a); //回溯的清理工作，把上一步的加入结果删除
            return false;
        }
    }

3、回溯法解题的一般步骤

 

（1）针对所给问题，确定问题的解空间： 首先应明确定义问题的解空间，问题的解空间应至少包含问题的一个（最优）解。


（2）确定结点的扩展搜索规则，搜索的结果一定要包括要求的解。


（3）以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索（求存在解的问题会出现剪枝）。

4、常见题目示例

 

77. Combinations

 

 

Given two integersnandk, return all possible combinations ofknumbers out of 1 ...n.

For example,
Ifn= 4 andk= 2, a solution is:

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

 

题目：从1----n中选出k个数作为组合，求出所有的组合具体的序列。

思路：回溯法，每次从下界开始遍历，到上界结束。满足size() == k 则加入结果，所有解都求出则结束遍历。也可以用二进制模拟的方法。

 

public class Solution {
    List<List<Integer>> res = new LinkedList<List<Integer>>();
    public List<List<Integer>> combine(int n, int k) {
        if(k==0)
            return res;
        helper(k,n,1,new LinkedList<Integer>());
        return res;

    }
    public void helper(int k,int n,int start,List<Integer> out){   
        if(k<=0)
            return;
        if(k == out.size()){
            List<Integer> temp = new LinkedList<Integer>(out);
            res.add(temp);
            return;
        }
        for(int i=start;i<=n;i++){
            out.add(i);
            helper(k,n,i+1,out);  //因为是组合，元素无关顺序，所以每次从下一步进行搜索
            out.remove(out.size()-1);
        }
    }
}

39. Combination Sum

 

Given asetof candidate numbers (C)(without duplicates)and a target number (T), find all unique combinations inCwhere the candidate numbers sums toT.

Thesamerepeated number may be chosen fromCunlimited 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 target7,
A solution set is:

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

题目：求一个set之中【没有相同的元素】，和为target的组合数。

思路：回溯，收集条件即为当前序列的 target == 0，其他和求组合一样。

 

public class Solution {
    public List<List<Integer>> list = new LinkedList<List<Integer>>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if(candidates.length == 0)
            return list;
        helper(candidates,target,new LinkedList<Integer>(),0);
        return list;

    }
    public void helper(int[] candidates,int target,List<Integer> temp,int start){ //维护一个target代表当前的和，0表示temp元素之和等于target，
        if(target<0)                                                              //为了便于判断收集条件
            return;
        if(target == 0){
            list.add(new LinkedList<Integer>(temp));
            return;
        }
        for(int i=start;i<candidates.length;i++){
            temp.add(candidates[i]);
            helper(candidates,target-candidates[i],temp,i);
            temp.remove(temp.size()-1);
        }
    }
}

40. Combination Sum II

 

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

Each number inCmay only be usedoncein 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 target8,
A solution set is:

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

题目：求一个set之中【有相同的元素】，和为target的组合数【组合不能重复】。

思路：在回溯之前的条件判断中加入和前一个元素相比，如果相同就不加入。 nums[i] == nums[i-1] continue;

 

public class Solution {
    public List<List<Integer>> list = new LinkedList<List<Integer>>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        if(candidates.length == 0)
            return list;
        helper(candidates,target,new LinkedList<Integer>(),0);
        return list;

    }
    public void helper(int[] candidates,int target,List<Integer> temp,int start){
        if(target<0)
            return;
        if(target == 0){
            list.add(new LinkedList<Integer>(temp));
            return;
        }
        for(int i=start;i<candidates.length;i++){
            if(i > start && candidates[i] == candidates[i-1]) continue;
            temp.add(candidates[i]);
            helper(candidates,target-candidates[i],temp,i+1);
            temp.remove(temp.size()-1);
        }
    }
}

216. Combination Sum III

 

Find all possible combinations ofknumbers that add up to a numbern, 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]]

 

题目：在1-----9中找出k个元素使其相加等于n

思路：和前面的题类似，回溯下界1 上界9 ，收集的时候限定条件改为 temp.size() == k && target == 0

 

public class Solution {
    List<List<Integer>> res = new LinkedList<List<Integer>>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        if(k == 0){
            return res;
        }
        hleper(n,k,1,new LinkedList<Integer>());
        return res;
    }
    public void hleper(int sum,int k,int start,List<Integer> templist){
        if(sum < 0) return;
        if(sum == 0 && templist.size()==k) {
            List<Integer> li = new ArrayList<Integer>(templist);
            res.add(li);
            return;
        }
        for(int i=start;i<=9;i++){
            templist.add(i);
            hleper(sum-i,k,i+1,templist);
            templist.remove(templist.size()-1);
        }

    }
}

46. Permutations

 

 

Given a collection ofdistinctnumbers, return all possible permutations.

For example,
[1,2,3]have the following permutations:

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

 

题目：求出0一串不同的数字的全排列。

思路：1、回溯法深搜，每次都从0------end搜索，不过需要有一个标记数组，来记录哪些已经访问过了，回溯的时候加入的元素以及标记都需要清除。

 

public class Solution {
    List<List<Integer>> res = new LinkedList<List<Integer>>();
    public List<List<Integer>> permute(int[] nums) {
        if(nums.length == 0)
            return res;
        int[] temp = new int[nums.length+1];
        helper(nums,new LinkedList<Integer>(),temp);
        return res;
    }
    public void helper(int[] nums,List<Integer> out,int[] visited){

        if(nums.length == out.size()){
            List<Integer> temp = new LinkedList<Integer>(out);
            res.add(temp);
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(visited[i] == 0){
                visited[i]=1;
                out.add(nums[i]);
                helper(nums,out,visited);
                visited[i]=0;           //标记清除
                out.remove(out.size()-1); //临时结果回溯
            }
        }
    }
}

47. Permutations II

 

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

For example,
[1,1,2]have the following unique permutations:

[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

题目：给出含有相同数字的元素，求所有元素的排列。

思路：当nums[i] == nums[i-1] 时候，直接进行下一轮搜索，因为如果进行深搜索的话，得出的结果会和之前的重复。即在if(条件处)限定具体的条件。

 

public class Solution {
    public List<List<Integer>> list = new LinkedList<List<Integer>>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        if(nums.length == 0)
            return list;
        int[] visited = new int[nums.length+1];
        helper(nums,new LinkedList<Integer>(),visited);
        return list;

    }
    public void helper(int[] nums,List<Integer> temp,int[] visited){
        if(temp.size() == nums.length){
            list.add(new LinkedList<Integer>(temp));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if (i>0 && nums[i]==nums[i-1]&&visited[i-1]==1) continue;  //具体的限定nums[i-1]==nums[i]则进行下一轮搜索，同时引入标记矩阵。
            if(visited[i] == 0){
                visited[i]=1;
                temp.add(nums[i]);
                helper(nums,temp,visited);
                visited[i]=0;
                temp.remove(temp.size()-1);
            }

        }

    }
}

22. Generate Parentheses

 

Givennpairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, givenn= 3, a solution set is:

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

题目：求出所有有效括号的全排列

思路：针对一个长度为2n的合法排列，第1到2n个位置都满足如下规则：左括号的个数大于等于右括号的个数

设left和right分别为剩余的左右括号数目，则使用递归求解可以分为以下几种情况
1、left>0  可以继续加括号
2、left=0 and right=0 结果收集
3、right>0 还需要满足right>left加入右括号

public class Solution {
    public List<String> list = new LinkedList<String>();
    public List<String> generateParenthesis(int n) {
        if(n == 0)
            return list;
        generate(n,n,"",list);
        return list;

    }
    public void generate(int left,int right,String res,List<String> list){
        if(left == 0 && right == 0){
            list.add(res);
            return;
        }
        if(left>0){
            generate(left-1,right,res+"(",list);
        }
        if(right>0 && right>left){
            generate(left,right-1,res+")",list);
        }

    }
}

78. Subsets

Given a set ofdistinctintegers,nums, return all possible subsets.

Note:The solution set must not contain duplicate subsets.

For example,
Ifnums=[1,2,3], a solution is:

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

题目：求一个集合的子集，集合中不包含相同元素

思路：1、二进制模拟运算，每一个组合代表一个二进制(1代表取，0代表不取)。2、回溯法，和求组合的方式类似，不过收集条件改为来一个收集一个，即不加任何

收集条件，也可以看成if(true) 收集;

//二进制模拟计算
public class Solution {
    List<List<Integer>> res = new LinkedList<List<Integer>>();
    public List<List<Integer>> subsets(int[] nums) {
        int n = nums.length;
        int count =1<<n;
        for(int i=0;i<count;i++){
            List<Integer> temp = new LinkedList<Integer>();
            int k=i;
            for(int j=0;j<n;j++){
                int flag = k&1;
                k=k>>1;
                if(flag==0)
                    temp.add(nums[j]);
            }
            res.add(temp);
        }
        return res;
    }
}

//回溯法
public class Solution {
    public List<List<Integer>> res = new LinkedList<List<Integer>>();
    public List<List<Integer>> subsets(int[] nums) {
        if(nums.length == 0)
            return res;
        helper(new LinkedList<Integer>(),0,nums);
        return res;

    }
    public void helper(List<Integer> temp,int start,int[] nums){
        res.add(new LinkedList<Integer>(temp));
        for(int i=start;i<nums.length;i++){
            temp.add(nums[i]);
            helper(temp,i+1,nums);
            temp.remove(temp.size()-1);
        }
    }
}

90. Subsets II

Given a collection of integers that might contain duplicates,nums, return all possible subsets.

Note:The solution set must not contain duplicate subsets.

For example,
Ifnums=[1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

题目：求含有重复元素的数组的子集合不能包含两个相同的子集合【和数学的集合不同】。

思路：先排序，递归进入下一层的条件 nums[i] != nums[i-1]。

public class Solution {
    public List<List<Integer>> res = new LinkedList<List<Integer>>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        if(nums.length == 0)
            return res;
        helper(new LinkedList<Integer>(),0,nums);
        return res;

    }
    public void helper(List<Integer> temp,int start,int[] nums){
        res.add(new LinkedList<Integer>(temp));
        for(int i=start;i<nums.length;i++){
            if(i>start && nums[i]==nums[i-1]) continue;
            temp.add(nums[i]);
            helper(temp,i+1,nums);
            temp.remove(temp.size()-1);
        }
    }
}

526. Beautiful Arrangement

Suppose you haveNintegers from 1 to N. We define a beautiful arrangement as an array that is constructed by theseNnumbers successfully if one of the following is true for the ithposition (1 ≤ i ≤ N) in this array:

The number at the ithposition is divisible byi.iis divisible by the number at the ithposition.

 

Now given N, how many beautiful arrangements can you construct?

Example 1:

Input: 2
Output: 2
Explanation: 

The first beautiful arrangement is [1, 2]:

Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).

Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).

The second beautiful arrangement is [2, 1]:

Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).

Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.

题目：这道题给了我们1到N，总共N个正数，然后定义了一种优美排列方式，对于该排列中的所有数，如果数字可以整除下标，或者下标可以整除数字，那么我们就是优美排列，让我们求出所有优美排列的个数。

思路：pos表示下标，排列完成，并记录排列位置，visited是否被访问，使用回溯。在进行下一步的搜索的时候条件

为 pos%i ==0 || i%pos == 0 && visited[i] = 0 没有被访问过并且可以被收集。收集条件为pso>n。

public class Solution {
    int count = 0;
    public int countArrangement(int N) {
        if(N == 0)
            return 0;
        int[] visited = new int[N+1];
        helper(visited,1,N);
        return count;
    }
    public void helper(int[] visited,int pos, int n){
        if(pos>n){
            count ++;
            return;
        }
        for(int i=1;i<=n;i++){
            if(visited[i] == 0 && (pos%i==0 || i%pos==0)){
                visited[i]=1;
                helper(visited,pos+1,n);
                visited[i]=0;
            }
        }
    }
}