回溯算法

1.基本概念

回溯算法實際上一個類似枚舉的搜索嘗試過程,主要是在搜索嘗試過程中尋找問題的解,當發現已不滿足求解條件時,就“回溯”返回,嘗試別的路徑。
回溯法是一種選優搜索法,按選優條件向前搜索,以達到目標。但當探索到某一步時,發現原先選擇并不優或達不到目標,就退回一步重新選擇,這種走不通就退回再走的技術為回溯法,而滿足回溯條件的某個狀態的點稱為“回溯點”。
許多復雜的,規模較大的問題都可以使用回溯法,有“通用解題方法”的美稱。

2.基本思想

在包含問題的所有解的解空間樹中,按照有限搜索的策略,從根節點出發深度探索解空間樹。當探索到某一接點時,要先判斷該結點是否包含問題的解,如果包含,就從該結點出發繼續探索,如果該結點不包含問題的解,則逐層想其祖先結點回溯。(回溯法就是對隱式的深度優先搜索算法)
若用回溯法求解問題的所有解時,要回溯到根,且根節點的所有可行的子樹都已經被所有遍才結束。而使用回溯法求解任一個解時,只要搜索到問題的一個解就可以結束。

3.解空間的樹結構

使用回溯法的解空間一般有兩種解空間:子集樹和排列樹

3.1子集樹

當所給的問題從n個元素的集合S中找出滿足某種性質的子集時,相應的解空間樹稱為子集樹。常用于0-1問題,如0-1背包問題。

如下圖:

image.png

3.2排列樹

當所給的問題是確定n個元素滿足某種性質的排列時,相應的解空間樹稱之為排列樹。排序樹通常有n!葉結點。

如下圖:

image.png

4.用回溯法解題的一般步驟

  1. 針對所給問題,確定問題的解空間:
    首先明確定義問題的解空間,問題的解空間應該至少包含問題的一個解
  2. 確定結點擴展搜索規則
  3. 以深度優先方式搜索解空間,并在搜索過程中用剪枝函數避免無效搜索

5.算法框架

1.問題框架

  設問題的解是一個n維向量(a1,a2,………,an),約束條件是ai(i=1,2,3,…..,n)之間滿足某種條件,記為f(ai)。

2.遞歸回溯框架

回溯法是對解空間的深度優先搜索,在一般情況下使用遞歸函數來實現回溯法比較簡單,其中i為搜索的深度,框架如下:

void backtrack (int t) //t表示遞歸深度
{
       if (t>n) output(x); //n表示深度界限
       else
         for (int i=f(n,t);i<=g(n,t);i++) // f(n,t),g(n,t)分別表示當前擴展結點未搜索過的子樹的起始編號和終止編號
           {
           x[t]=h(i); 
           if (constraint(t)&&bound(t)) //滿足約束函數和限界函數
              backtrack(t+1);
           }
}

3.非遞歸的算法框架

void iterativeBacktrack ()
{
  int t=1;
  while (t>0) {
    if (f(n,t)<=g(n,t)) 
      for (int i=f(n,t);i<=g(n,t);i++) {
        x[t]=h(i);
        if (constraint(t)&&bound(t)) {
          if (solution(t)) output(x);
          else t++;}
        }
    else t--;
    }
}

6.舉個例子

現在舉個例子,給定一組數組nums,再給定一個目標值target,找出集合nums的所有子集使其之和剛好為目標值,nums中的數只能使用一次。

例如:給定數組nums = {1,2,3,4,5},給定目標值target = 9,那么所能得到的結果有:

[0, 1, 1, 1, 0]
[0, 0, 0, 1, 1]

也即是:2+3+4和4+5

現在我們來考慮一下如何求解這個題,要找出所有子集,這顯然有點“窮舉搜索”的感覺,回溯就是這樣一種“搜索”算法。

那么按照回溯步驟:

6.1 確定問題的解空間

用0/1表示是否是用集合中某個元素,那么對于整個集合,我們可以定義一個數組x,x[i]=0,則表示不使用第i個元素;x[i]=1,表示是用該元素。這樣就將問題轉化問了經典的0-1問題,而二叉樹天然具有這樣的性質(左子樹對應1,右子樹對應0,當然也可以反過來定義)。構造出的解空間樹如上文中的子集樹。這里就不贅述了。

6.2 確定結點擴展搜索規則

這個沒什么好說的,大多數回溯問題均使用深度遍歷。

6.3 進行搜索,必要時加入剪枝函數

什么是剪枝函數?其實這是一個很形象的名詞,在上文中我們構造了一個解空間樹,那么這顆樹就有很多分支。在搜索過程中,我們可以將一些明顯不可能產生解的分支給去掉,降低搜索次數。如果我們不使用剪枝函數,那么就會全部進行遍歷,這往往不是我們想要的。

首先貼上不加剪枝函數的代碼:

import java.util.Arrays;

public class Main {

    /**
     * 回溯法
     *
     */
    static int[] nums = {1,2,3,4,5};
    static int target = 9;
    static int n = nums.length;
    static int[] currentX = new int[n];
    public static void main(String[] args) {
        backTrack(0);
    }

    static int iter = 0;
    static void backTrack(int i ) {
        if(i == n) {
            //結束
            return;
        }
        //求和
        int currentSum = sum(currentX);
        if(currentSum+nums[i] < target) {
            //滿足約束條件
            currentX[i] = 1;
            backTrack(i+1);
        }else if(currentSum+nums[i]  == target) {
            //滿足約束條件
            currentX[i] = 1;
            System.out.println(Arrays.toString(currentX));
            return;
        }
        //準備進入右子樹,不一定能進入
        currentX[i] = 0;
        //不滿足約束條件,加入剪枝函數,減低遍歷次數
        //設計規則:當前和只加上右子樹的最大值都無法達到target,則不用進入右子樹
       // if(currentSum + bound(i+1) >= target) {
            System.out.println(++iter);
            backTrack(i+1);
        //}

    }
    static int bound(int i) {
        int sum = 0;
        for(;i<n;i++) {
            sum+=nums[i];
        }
        return sum;
    }
    static int sum(int[] x) {
        int sum = 0;
        for (int i = 0; i < x.length; i++) {
            if(x[i] == 1) {
                sum+=nums[i];
            }
        }
        return sum;
    }

}

這里我將代碼中的剪枝函數注釋掉了,下面是運行結果:

1
2
3
4
5
6
7
8
9
[1, 0, 1, 0, 1]
10
11
12
13
[0, 1, 1, 1, 0]
14
15
16
17
18
19
20
21
[0, 0, 0, 1, 1]
22
23

進入右子樹23次,一共有三個解。

現在我們將注釋刪掉,運行結果如下:

1
2
3
4
[1, 0, 1, 0, 1]
5
6
7
[0, 1, 1, 1, 0]
8
9
10
11
[0, 0, 0, 1, 1]

可以看到,進入右子樹的次數只有11次了,也就是加入剪枝函數后,我們的搜索次數減少了12次。顯然這是很可觀。

7.最后

回溯法的介紹大概就這么多了,回溯法能夠找到所有滿足約束條件的解,還有一種常用求解優化問題的算法-分支限界法,用來求解滿足約束條件的一個解。

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。