算法学习（一）回溯法

1、概念

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

   回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

     许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。

2、基本思想

   在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。（其实回溯法就是对隐式图的深度优先搜索算法）。

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

       而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。

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

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

    （2）确定结点的扩展搜索规则

    （3）以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

4、基本方法

1.递归

//针对B+树的递归回溯方法
void backtrack (int t)//初始条件
{
	if (t == n) output(x); //从0开始，叶子节点，输出结果，x是可行解
	else
		for i=1 to k    //当前节点的所有子节点
		{
			x[t]=value(i);    //每个子节点的值赋值给x
			if (constraint(t)&&bound(t)) //满足约束条件和限界条件
			backtrack(t+1);	//递归下一层
		}
}

2.递推

//针对N叉树的迭代回溯方法
void iterativeBacktrack ()
{
	int t=1;
	while (t>0) {
		if(ExistSubNode(t)) //当前节点的存在子节点
		{
			for i = 1 to k  //遍历当前节点的所有子节点
			{
				x[t]=value(i);//每个子节点的值赋值给x
				if (constraint(t)&&bound(t))//满足约束条件和限界条件 
				{
					//solution表示在节点t处得到了一个解
					if (solution(t)) output(x);//得到问题的一个可行解，输出
					else t++;//没有得到解，继续向下搜索
				}
			}
		}
		else //不存在子节点，返回上一层
		{
			t--;
		}
	}
}

5、几种问题类型

1、子集树

 所给的问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间成为子集树。

如0-1背包问题，从所给重量、价值不同的物品中挑选几个物品放入背包，使得在满足背包不超重的情况下，背包内物品价值最大。它的解空间就是一个典型的子集树。

此类题型基本范式：

void backtrack (int t)
{
  if (t == n) output(x);  //输出结果
    else
      for (int i = 0;i <= n;i++) {
        if (constraint(t)&&bound(t)) { //边界条件与问题限制条件
                x[t] = i;         //（t,i）处确定值
                backtrack(t+1);   //探测下一层
             }
      }
}

LeetCode例题：子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

输入: nums = [1,2,3]
输出:
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

class Solution {
    List<List<Integer>> listAll = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        if (nums.length == 0) { return listAll; }
        helper(nums,0,new ArrayList<>());    //从0个数开始直到n个数的排列
        return listAll;
    }
    public void helper(int[] nums,int k,List<Integer> list) {
        listAll.add(new ArrayList<>(list));         //记录K个数时的结果
        for (int j = k;j < nums.length;j++) {  
            list.add(nums[j]);
            helper(nums,j+1,list);          //下一层子树
            list.remove(list.size()-1);//回溯到上一层的状态
        }
    }
}

 

2、排列树

所给的问题是确定n个元素满足某种性质的排列时，相应的解空间就是排列树。

LeetCode例题：括号生成

给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

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

class Solution {
    List<String> list = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        helper("",0,0,n);
        return list;
    }
    
    void helper(String s,int l,int r,int n) {
        if (s.length() == 2*n) {  //用完所有括号，返回结果
            list.add(s);
            return;
        }
        if (l < n) { helper(s+"(",l+1,r,n); }  //左括号小于总数，可以放左括号
        if (r < l) { helper(s+")",l,r+1,n); }  //右括号小于左括号数，可以放右括号
    }
}

此类问题为排列树问题，即n个元素的全排列的满足条件子集，此类问题范式如下

void backtrack (int t)
{
  if (t>n) output(x);
    else
      for (int i=t;i<=n;i++) {
        swap(x[t], x[i]);
        if (constraint(t)&&bound(t)) backtrack(t+1);
        swap(x[t], x[i]);        //回溯排列到上一层的位置
      }
} 

3、八皇后

问题描述：八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。

约束条件：

                  1. a[0] ~ a[7]不能相同，存储棋子所在的列

                  2. 同一对角线上即坐标斜率为1，即（i，j）和（k，l）的位置，当|i-k|=|j-l| 时，两个皇后才在同一条对角线上。

递归回溯：

  int[] a = new int[n];  //存储皇后位置的数组，下标为行，值位列
  void Queen(int k,int n) {
       if (k == n) {   // k从0开始，到达了最后一行n-1之后
           System.out.println(Arrays.toString(a)); //打印输出
           return;
       }
       for (int i = 0;i < n;i++) {    //k行的每一列都有可能放置皇后
           if (isConflict(k,i)) {     //判断此处的K行，i列能否满足放置要求
               a[k] = i;           
               Queen(k+1,n);          //（k，i）处放置完成后，进行下一行的探测
           }
       }
   }
   boolean isConflict(int k,int i) {    //判断函数，扫描0到k-1行中是否有根（k,i）冲突
        for (int j = 0;j < k;j++) {
            if (a[j] == i || Math.abs(a[j]-i) == k-j) { //同列或者同一斜线
                return false;
            }
        }
        return true;
   }

各种大神解法：https://blog.csdn.net/hacker00011000/article/details/51582300

 

 

 

 

 

参考文章：https://blog.csdn.net/JarvisChu/article/details/16067319

https://www.cnblogs.com/steven_oyj/archive/2010/05/22/1741376.html