Backtracking(回溯算法)

Backtracking(回溯算法)

1. 定义

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

2.适用场景

一般来讲，会设置一个递归函数，函数的参数会携带一些当前的可能解的信息，根据这些参数得出可能解或者不可能而回溯.
可以应用的场景有：N皇后、数独、集合等。
回溯算法其实是暴力求解的一种优化。

3.算法伪码

来自维基百科

In order to apply backtracking to a specific class of problems, one must provide the data P for the particular instance of the problem that is to be solved, and six procedural parameters, root, reject, accept, first, next, and output. These procedures should take the instance data P as a parameter and should do the following:

root(P): return the partial candidate at the root of the search tree.
reject(P,c): return true only if the partial candidate c is not worth completing.
accept(P,c): return true if c is a solution of P, and false otherwise.
first(P,c): generate the first extension of candidate c.
next(P,s): generate the next alternative extension of a candidate, after the extension s.
output(P,c): use the solution c of P, as appropriate to the application.
The backtracking algorithm reduces the problem to the call bt(root(P)), where bt is the following recursive procedure:

procedure bt(c)
  if reject(P,c) then return
  if accept(P,c) then output(P,c)
  s ← first(P,c)
  while s ≠ NULL do
    bt(s)
    s ← next(P,s)

4.例子

leetcode 216题 https://leetcode.com/problems/combination-sum-iii/

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

BackTracking Solution:

class Solution {
   public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> ans = new ArrayList<>();
        backTracing(ans, new ArrayList<>(), k, n, 1);
        return ans;
    }

    private void backTracing(List<List<Integer>> ans, List<Integer> comb, int k, int n, int start) {
        if (comb.size() == k && n == 0) {
            List<Integer> list = new ArrayList<>(comb);
            ans.add(list);
            return;
        } else if (comb.size() == k || n == 0) {
            return;
        } else {
            for (int i = start; i <= 9 ; i++) {
                comb.add(i);
                backTracing(ans, comb, k, n - i, i+1);
                comb.remove(comb.size() - 1);
            }
        }
    }
    
}