2. 程式人生 > 其它 >回溯演算法小結(java)

回溯演算法小結(java)

阿新 • • 發佈：2020-12-12

技術標籤：數字結構和演算法javaleetcode資料結構演算法

回溯演算法小結

1.回溯演算法定義：

回溯法採用試錯的思想，它嘗試分步的去解決一個問題。在分步解決問題的過程中，當它通過嘗試發現現有的分步答案不能得到有效的正確的解答的時候，它將取消上一步甚至是上幾步的計算，再通過其它的可能的分步解答再次嘗試尋找問題的答案。回溯法通常用最簡單的遞迴方法來實現，在反覆重複上述的步驟後可能出現兩種情況：

找到一個可能存在的正確的答案；
在嘗試了所有可能的分步方法後宣告該問題沒有答案；

(來自維基百科)

1.1 回溯演算法和深度優先遍歷

回溯演算法也叫 回溯搜尋演算法，「搜尋」即「搜尋所有的解」。回溯演算法從初始狀態出發，採用 深度優先遍歷

的方式，得到問題的 所有的解。因為採用遍歷的方式，所以可以得到所有的解。回溯在某種程度上也是暴力搜尋。

1.2 回溯演算法適用範圍

題目常見的形式就是問某一個問題的所有解決方案。如果解決一個問題有多個解決方案，每一個解決方案有多個步驟，題目要求我們得到所有的解，就可以使用回溯演算法。多個解決方案，每一個解決方案有多個步驟，通常可以建模成一個 樹形問題。而樹形問題中有著很明顯的遞迴結構，因此 回溯演算法遞迴地建立了區域性的可能的解決方案，當發現一個可能的解決方案無法得出正確的結果時，回退到上一步，嘗試下一個可能的解決方案 ，這裡的 **「回退」就是「回溯」**的意思。

1.3 例題

46. 全排列

public class permute {
    public List<List<Integer>> permute(int[] nums) {
        int len=nums.length;
        List<List<Integer>> res=new ArrayList<>();
        if(len==0) return res;
        Deque<Integer> path=new ArrayDeque<>();
        boolean[] used=
 
new boolean[len];
        backTrack(nums,len,0,path,used,res);
        return res;
    }

    /**
     *
     * @param nums
     * @param len
     * @param index  當前需要確定的path中的元素的下標
     * @param path  記錄當前的路徑
     * @param used 記錄已經被選擇的數字
     * @param res
     */
    public void backTrack(int[] nums,int len,int index,Deque<Integer> path,boolean[] used,List<List<Integer>> res){
        // 遞迴終止條件
        if(index==len)
        {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < len; i++) {
            if(used[i]) continue;
            used[i]=true;
            path.offerLast(nums[i]);
            backTrack(nums,len,index+1,path,used,res);
            path.pollLast();
            used[i]=false;
        }

    }
}

113. 路徑總和 II

public class pathSum {
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> path = new ArrayDeque<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if (root == null) return res;
        backTrack(root, sum);
        return res;
    }

    /**
     *
     * @param root
     * @param sum
     */

    public void backTrack(TreeNode root, int sum) {
        // 首先考慮終止條件
        if (root==null) {
            return;
        }
        path.offerLast(root.val);
        sum-=root.val;
        if(root.left==null && root.right==null &&sum==0) res.add(new ArrayList<>(path));
        backTrack(root.left,sum);
        backTrack(root.right,sum);
        path.pollLast();
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(4);

    }
}

2. 剪枝

回溯演算法其實是一個遍歷的演算法，通過遍歷搜尋所有的解 其實是沒有技巧的，並且時間複雜度很高。因此在遍歷的時候，如果能夠提前知道 即將要遍歷分支 不能搜尋到符合條件的結果，這一分支就可以跳過，這一步操作就像是在一棵樹上剪去一個枝葉，因此稱為 剪枝。在我個人看來，剪枝一般體現在backTrack函式中，for迴圈遍歷所有元素時，新增一個if，滿足某種條件的直接continue

47. 全排列 II

public class permuteUnique {
    List<List<Integer>> res=new ArrayList<>();
    Deque<Integer> path=new ArrayDeque<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        int len=nums.length;
        if(len==0) return res;
        Arrays.sort(nums);
        boolean[] used=new boolean[len];
        backTrack(nums,len,0,used);
        return res;
    }
    public void backTrack(int[] nums,int len,int index,boolean[] used){
        if(len==index){
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < len; i++) {
            if(used[i]) continue;
            // 剪枝條件
            if(i>0 && nums[i]==nums[i-1] && !used[i-1]) continue;
            used[i]=true;
            path.offerLast(nums[i]);
            backTrack(nums,len,index+1,used);
            path.pollLast();
            used[i]=false;
        }
    }

    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> path = new ArrayDeque<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        int len = candidates.length;
        if (len == 0) return res;
        backTrack(candidates, target, len ,0);
        return res;

    }

    public void backTrack(int[] candidates, int target, int len, int begin) {
        if (target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i < len; i++) {
            if (target < candidates[i]) return;

            path.offerLast(candidates[i]);
            backTrack(candidates, target-candidates[i], len ,i);

            path.pollLast();
        }

39. 組合總和

public class combinationSum {
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> path = new ArrayDeque<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        int len = candidates.length;
        if (len == 0) return res;
        backTrack(candidates, target, len ,0);
        return res;

    }

    public void backTrack(int[] candidates, int target, int len, int begin) {
        if (target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i < len; i++) {
            if (target < candidates[i]) return;

            path.offerLast(candidates[i]);
            backTrack(candidates, target-candidates[i], len ,i);

            path.pollLast();
        }
    }

    public static void main(String[] args) {
        int[] candidates = {2, 3, 6, 7};
        combinationSum cs = new combinationSum();
        List<List<Integer>> lists = cs.combinationSum(candidates, 7);
        System.out.println(lists);
    }
}

注意理解begin在裡面所起到的作用：

  • 沒用begin時，candidates = [2,3,6,7], target = 7,答案：image-20201211205239381

  • 使用後答案：image-20201211205153544

區別在於前者把同樣元素的List當成不同答案了。

打個比方，當2開頭的方案被遍歷完了之後，方法中的begin相當於+1了，所以從3開始的方案中，不再重複出現前面出現過的2.

注意，這裡就是此題可以用begin排除重複方案的原因。用used陣列可以起到一樣的效果，但是這裡begin相對佔用的時間和空間更小。

40. 組合總和 II

public class combinationSum2 {
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> path = new ArrayDeque<>();

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        int len = candidates.length;
        if (len == 0) return res;
        Arrays.sort(candidates);

        backTrack(candidates, target, len ,0);
        return res;

    }

    public void backTrack(int[] candidates, int target, int len, int begin) {
        if (target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i < len; i++) {
            if (target < candidates[i]) return;
            // 剪枝 有重複數字導致的重複方案
            if(i>begin && candidates[i]==candidates[i-1]) continue;
            path.offerLast(candidates[i]);
            // i+1是因為不能重複使用
            backTrack(candidates, target-candidates[i], len ,i+1);

            path.pollLast();
        }
    }

    public static void main(String[] args) {
        int[] candidates = {10,1,2,7,6,1,5};
        combinationSum2 cs = new combinationSum2();
        List<List<Integer>> lists = cs.combinationSum2(candidates, 8);
        System.out.println(lists);
    }
}

注意思考剪枝過程的那一句是怎麼起作用的，為什麼前面直接return 但是後面用continue

if(i>begin && candidates[i]==candidates[i-1]) continue;

因為，該陣列事先排序過了，當target<candidates[i]後，無論i遍歷到後面的哪個元素，都成立，所以可以直接return。

第二個主要是刪除重複方案，不代表後面的i組成的方案都不成立。

---- 未完 待續 內容主要參考自https://leetcode-cn.com/leetbook/read/learning-algorithms-with-leetcode/9el6vj/

if(i>begin && candidates[i]==candidates[i-1]) continue;

因為，該陣列事先排序過了，當target<candidates[i]後，無論i遍歷到後面的哪個元素，都成立，所以可以直接return。

第二個主要是刪除重複方案，不代表後面的i組成的方案都不成立。

---- 未完 待續 內容主要參考自https://leetcode-cn.com/leetbook/read/learning-algorithms-with-leetcode/9el6vj/

相關推薦

回溯演算法小結(java)

技術標籤：數字結構和演算法javaleetcode資料結構演算法 回溯演算法小結 1.回溯演算法定義：

java 實現迷宮回溯演算法示例詳解

用一個7 x 7的矩形表示迷宮，0和1分別表示的是通路和障礙。通過設計編寫程式找到藍色小球達到藍色旗子的路線

回溯演算法之八皇后問題（Java實現）

要求用回溯法求解 8-皇后問題 八皇后問題：使放置在 8*8 棋盤上的 8 個皇后彼此不受攻擊。

回溯演算法之裝載問題（Java實現）

問題描述 用回溯法編寫一個遞迴程式解決如下裝載問題： 有 n 個集裝箱要裝上 2 艘載重分別為 c1 和 c2的輪船，其中集裝箱 i 的

[leetbook中級演算法-回溯演算法(java解法)]LC單詞搜尋

技術標籤：演算法練習leetbook剪枝leetcode字串dfs回溯 leetbook:中級演算法 型別:回溯演算法

【讀書筆記：演算法小抄】回溯演算法·全排列——Java實現

技術標籤：# Java學習筆記# 演算法小抄# 每天學一點程式設計java演算法leetcode資料結構回溯演算法

劍指offer計劃7（搜尋與回溯演算法簡單版）---java

1.1、題目1 劍指 Offer 26. 樹的子結構 1.2、解法 這題看了解法，感嘆真的6，程式碼量減了很多。

劍指offer計劃19（ 搜尋與回溯演算法中等）---java

1.1、題目1 劍指 Offer 64. 求1+2+…+n 1.2、解法 這題看評論區真的絕了，都是人才，各個說話都好聽，我看到個還有用異常來結束的就離譜。

劍指offer計劃28（搜尋與回溯演算法困難）---java

1.1、題目1 劍指 Offer 37. 序列化二叉樹 1.2、解法 這題給我笑死了，我看到題解有個解法，我願稱之為神。

十大經典排序演算法（java）

十大經典排序演算法最強總結（含JAVA程式碼實現） 轉載（https://www.cnblogs.com/guoyaohua/p/8600214.html）

一致性hash演算法及java實現

一致性hash演算法是分散式中一個常用且好用的分片演算法、或者資料庫分庫分表演算法。現在的網際網路服務架構中，為避免單點故障、提升處理效率、橫向擴充套件等原因，分散式系統已經成為了居家旅行必備的部署模

雪花演算法Twitter的分散式自增ID演算法snowflake (Java版)

概述 分散式系統中，有一些需要使用全域性唯一ID的場景，這種時候為了防止ID衝突可以使用36位的UUID，但是UUID有一些缺點，首先他相對比較長，另外UUID一般是無序的。

【演算法Part2】回溯演算法

一.概念   回溯演算法實際上一個類似列舉的搜尋嘗試過程，主要是在搜尋嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就 “回溯” 返回，嘗試別的路徑。

演算法 回溯演算法套路模板

回溯演算法應用 經典的全排列和N皇后 怎麼窮舉全排列的呢？比方說給三個不重複數 [1,2,3]，你肯定不會無規律地亂窮舉，一般是這樣：

leetcode刷題記錄：回溯演算法注意事項

leetcode 46題： 給定一個沒有重複數字的序列，返回其所有可能的全排列。 輸入: [1,2,3]

讀書筆記：《資料結構與演算法分析Java語言描述》

目錄第 3 章 表、棧和佇列3.2 表 ADT3.2.1 表的簡單陣列實現3.2.2 簡單鏈表3.3 Java Collections API 中的表3.3.1 Collection 介面3.3.2 Iterator 介面3.3.3 List介面、ArrayList 類和 LinkedList 類3.3.5 關於 List

回溯演算法

一、什麼是回溯演算法 回溯演算法實際上一個類似列舉的搜尋嘗試過程，主要是在搜尋嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就“回溯”返回，嘗試別的路徑。許多複雜的，規模較大的問題都可以

演算法小結(一)

一、求解步驟 1、問題分析 題目中給出的資訊分析，審查問題的描述 2、數學模型建立

LeetCode一刷：回溯演算法-子集

問題描述： 子集給定一組不含重複元素的整數陣列nums，返回該陣列所有可能的子集（冪集）。

Peterson's Algothrim’演算法的Java實現和C++實現

事實上Java實現並沒有成功，不知為何總會有似乎是死鎖的情況發生，任務並不能執行結束。