聊聊算法——回溯算法

時間 2020-05-16

標籤聊聊算法回溯简体版

原文原文鏈接

「遞歸只應天上有，迭代還須在人間」，從這句話咱們能夠看出遞歸的精妙，確實厲害，遞歸是將問題規模逐漸減少，node

而後再反推回去，但本質上是從最小的規模開始，直到目標值，思想就是數學概括法，舉個例子，求階乘 N!=(N-1)！*N ，算法

而迭代是數學中的極限思想，利用前次的結果，逐漸靠近目標值，迭代的過程當中規模不變，舉例如For循環，直到終止條件。數組

遞歸的思想不復雜，但代碼理解就麻煩了，要理解一個斐波那契數組遞歸也不難，好比下面的回溯算法遞歸，for 循環裏面數據結構

帶遞歸，看代碼是否是暈了？好，下面咱們專門來聊聊這個框架！框架

做者原創文章，謝絕一切形式轉載，違者必究！編輯器

準備：分佈式

Idea2019.03/JDK11.0.4函數

難度： 新手--戰士--老兵--大師微服務

目標：學習

回溯算法分析與應用

1 回溯算法

先給出個回溯算法框架：

backtrack(路徑，選擇列表){
    //結束條件
    將中間結果加入結果集
    for 選擇 in 選擇列表:
        //作選擇，並將該選擇從選擇列表中移除
        路徑.add(選擇)
        backtrack(路徑，選擇列表)      
        //撤銷選擇 
        路徑.remove(選擇)
}

爲了理解上述算法，回想一下，我前篇文章中有說到，多路樹的遍歷算法框架：

private static class Node {
    public int value;
    public Node[] children;
}
public static void dfs(Node root){
    if (root == null){
        return;
    }
    // 前序遍歷位置，對node作點事情
    for (Node child:children
    ) {
        dfs(child);
    }
    // 後序遍歷位置，對node作點事情
}

若是去掉路徑增長/撤銷的邏輯，是否是和多路樹的遍歷算法框架同樣了呢？其實就是一個多路樹DFS的變種算法！

另外，雖然遞歸代碼的理解難度大，運行時是棧實現，但看官不要掉進了遞歸棧，不然就出不來了，若是試着用打斷

點逐行跟進的辦法非要死磕，那對不起，估計三頓飯功夫也可能出不來，甚至我懷疑起本身的智商來，因此，理解遞歸，

核心就是抓住函數體來看，抽象的理解，只看懂 N 和 N-1 的轉移邏輯便可！不懂的先套用再說，也不定哪天就靈感來了，

一下頓悟！

那就先上菜了！先是經典回溯算法，代號A，咱們要作個數組全排列，我看別人說回溯算法也都是拿這個例子說事，

我就落個俗套：

class Permutation {
    // 排列組合算法
    private static List<List<Integer>> output = new LinkedList();
    static List<List<Integer>> permute( List<Integer> nums, // 待排列數組
                                         int start //起始位置
     ){
        if (start == nums.size()){
            output.add(new ArrayList<>(nums));
        }
        for (int i = start; i < nums.size(); i++) {
            // 作選擇，交換元素位置
            Collections.swap(nums, start, i);
            // 遞歸，縮小規模
            permute( nums,start +1);
            // 撤銷選擇，回溯，即恢復到原狀態,
            Collections.swap(nums, start, i);
        }
        return output;
    }
    // 測試
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1,2,3,4);
        List<List<Integer>> lists = permute(nums,0);
        lists.forEach(System.out::println);
    }
}

代碼理解：數組 {1,2,3} 的全排列，咱們立刻知道有{1,2,3},{1,3,2},{2,1,3},{2,3,1},{3,1,2},{3,2,1}排列，具體過程就是經過遞歸縮小規模，

作 {1,2,3} 排列，先作 {2,3} 排列，前面在加上 1 便可，繼續縮小，就是作 {3} 的排列。排列就是同一個位置把全部不一樣的數都放一次，

那麼代碼實現上可以使用交換元素法，好比首個位置和全部元素都交換一遍，不就是所有可能了嗎。這樣，首個位置全部可能就遍歷了

一遍，而後在遞歸完後，恢復(回溯)一下，就是說每次交換都是某一個下標位置，去交換其餘全部元素。

再來個全排列的算法實現，代號B，也是使用回溯的思想：

public class Backtrack {
    public static void main(String[] args) {
       int[] nums = {1,2,3,4};
        List<Integer> track = new LinkedList<>();
        List<List<Integer>>  res = backtrack(nums,track);
        System.out.println(res);
    }
    // 存儲最終結果
    private static List<List<Integer>> result = new LinkedList<>();
    // 路徑：記錄在 track 中
    // 選擇列表：nums 中不存在於 track 的那些元素
    // 結束條件：nums 中的元素全都在 track 中出現
    private static List<List<Integer>> backtrack(int[] nums,List<Integer> track){
        // 結束條件
         if (track.size() == nums.length){
             result.add(new LinkedList<>(track));
             return null;
         }
        for (int i = 0; i < nums.length; i++) {
            if (track.contains(nums[i]))
                continue;
            // 作選擇
            track.add(nums[i]);
            backtrack(nums,track);
            // 撤銷選擇
            track.remove(track.size()-1);
        }
        return result;
    }
}