LeetCode通關:連刷十四題,回溯演算法完全攻略

三分惡 發表於 2021-09-14
演算法 LeetCode

刷題路線:https://github.com/youngyangyang04/leetcode-master

大家好,我是被演算法題虐到淚流滿面的老三,只能靠發發文章給自己打氣!

這一節,我們來看看回溯演算法。

回溯演算法

回溯演算法理論基礎

什麼是回溯

在二叉樹的路徑問題裡,其實我們已經接觸到了回溯這種演算法。

例如我們在查詢二叉樹所有路徑的時候,查詢完一個路徑之後,還需要回退,接著找下一個路徑。

二叉樹所有路徑

回溯其實可以說是我們熟悉的DFS,本質上是一種暴力窮舉演算法,把所有的可能都列舉出來,所以回溯並不高效。

這個可能比較抽象,我們舉一個例子吧,[1,2,3]三個數可以構成多少種組合呢?

我們的辦法就是把所有結果都窮舉出來,那怎麼窮舉呢?可以第一位選1,第二位從[2,3]裡選2,第三位從[3]裡選3;第二個組合可以第一位選2……

我們把這個選擇抽象成一棵樹,初步有個印象,這是全排列的問題,後面會刷到。

抽象樹

回溯演算法模板

回溯演算法,可以看作一個樹的遍歷過程,建議可以去看一下N叉樹的遍歷,和這個非常類似。

遞迴有三要素,類似的,回溯同樣需要關注三要素:

  • 返回值和引數

回溯演算法中函式返回值一般為void。

回溯方法的引數得結合實際問題,但是一般需要一個類似棧的結構來儲存每個路徑(結果),因為我們一次遞迴結束之後,節點要回溯到上一個位置。

回溯方法虛擬碼如下:

void backtrack(引數)
  • 回溯函式終止條件

和遞迴一樣,回溯同樣也要有結束條件。

什麼時候達到了終止條件,從樹的角度來講,一般來說搜到葉子節點了,對回溯而言,就是找到了滿足條件的一個結果。

所以回溯函式終止條件虛擬碼如下:

if (終止條件) {
    存放結果;
    return;
}
  • 回溯搜尋的遍歷過程

回溯法一般是在一個序列裡做選擇,序列的大小構成了樹的寬度,遞迴的深度構成的樹的深度。

回溯函式遍歷過程虛擬碼如下:

for (選擇:本層集合中元素(樹中節點孩子的數量就是集合的大小)) {
    處理節點;
    backtracking(路徑,選擇列表); // 遞迴
    回溯,撤銷處理結果
}

for迴圈就是遍歷序列,可以理解一個節點有多少個孩子,這個for迴圈就執行多少次。可以理解為橫向的遍歷。

backtrack就是自己呼叫自己,可以理解為縱向的遍歷。

回溯演算法模板

同時遞迴之後,我們還要撤銷之前做的選擇。

所以回溯演算法模板框架如下:

void backtrack(引數) {
    if (終止條件) {
        存放結果;
        return;
    }

    for (選擇:本層集合中元素(樹中節點孩子的數量就是集合的大小)) {
        處理節點;
        backtrack(路徑,選擇列表); // 遞迴
        回溯,撤銷處理結果
    }
}

回溯能解決哪些問題

回溯法,一般可以解決如下幾種問題:

  • 組合問題:N個數裡面按一定規則找出k個數的集合
  • 切割問題:一個字串按一定規則有幾種切割方式
  • 子集問題:一個N個數的集合裡有多少符合條件的子集
  • 排列問題:N個數按一定規則全排列,有幾種排列方式
  • 棋盤問題:N皇后,解數獨等等

可能到這對回溯還比較迷茫,沒有關係,回溯是比較套路化的一種演算法,多做幾道題就明白了。

組合問題

LeetCode77. 組合

☕ 題目:77. 組合 (https://leetcode-cn.com/problems/combinations/)

❓ 難度:中等

📕 描述:

給定兩個整數 nk,返回範圍 [1, n] 中所有可能的 k 個數的組合你可以按 任何順序 返回答案。

示例 1:

輸入:n = 4, k = 2
輸出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2:

輸入:n = 1, k = 1
輸出:[[1]]

💡 思路:

這道題是回溯演算法的經典題目。

我們來看一下這道題的抽象樹形結構:

組合抽象樹結構

按照我們的回溯模板,看看這道題應該怎麼寫:

  • 返回值、引數

首先方法裡是一定要區間的資料,[start,n]。

計數的k也不可缺少。

最後的結果集合result,還有每條路徑的結果path,可以定義全域性變數,來提升可讀性。

  • 終止條件

什麼時候終止,就是什麼時候到葉子節點了呢?結果parh的大小等於k,說明到了葉子節點,一次遞迴結束。

  • 單層邏輯

在單層邏輯裡面,我們要做兩件事:

  1. 遍歷序列
  2. 遞迴,遍歷節點

組合單層邏輯

🖊 程式碼:

class Solution {
    //結果集合
    List<List<Integer>> result;
    //符合條件的結果
    LinkedList<Integer> path;

    public List<List<Integer>> combine(int n, int k) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backstack(n, k, 1);
        return result;
    }

    //回溯
    public void backstack(int n, int k, int start) {
        //結束條件
        if (path.size() == k) {
            result.add(new LinkedList<>(path));
            return;
        }
        for (int i = start; i <= n; i++) {
            path.addLast(i);
            //遞迴
            backstack(n, k, i + 1);
            //回溯,撤銷已經處理的節點
            path.removeLast();
        }
    }
}

⚡ 剪枝優化

回溯中,提高效能的一大妙招就是剪枝。

剪枝見名知義,就是在把我們的樹的一些樹枝給它剪掉。

例如n = 4,k = 4

剪枝優化

我們可以看到,有些路徑,其實一定是不滿足我們的要求,如果我們把這些不可能的路徑剪斷,那我們不就可以少遍歷一些節點嗎?

所以我們看看這道題怎麼來剪這個枝:

如果for迴圈選擇的起始位置之後的元素個數 已經不足 我們需要的元素個數了,那麼就沒有必要搜尋

  1. 已經選擇的元素個數:path.size();
  2. 還需要的元素個數為: k - path.size();
  3. 所以起始位置 : n - (k - path.size()) + 1之後的肯定不符合要求

所以優化之後的程式碼如下:

class Solution{
      //結果集合
    List<List<Integer>> result;
    //符合條件的結果
    LinkedList<Integer> path;

    public List<List<Integer>> combine(int n, int k) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backstack(n, k, 1);
        return result;
    }

    //回溯
    public void backstack(int n, int k, int start) {
        //結束條件
        if (path.size() == k) {
            result.add(new LinkedList<>(path));
            return;
        }
        for (int i = start; i <= n-(k-path.size())+1; i++) {
            path.addLast(i);
            //遞迴
            backstack(n, k, i + 1);
            //回溯,撤銷已經處理的節點
            path.removeLast();
        }
    }
}

LeetCode216. 組合總和 III

☕ 題目:77. 組合 (https://leetcode-cn.com/problems/combinations/)

❓ 難度:中等

📕 描述:

找出所有相加之和為 n 的 k 個數的組合。組合中只允許含有 1 - 9 的正整數,並且每種組合中不存在重複的數字。

說明:

  • 所有數字都是正整數。
  • 解集不能包含重複的組合。

示例 1:

輸入: k = 3, n = 7
輸出: [[1,2,4]]

示例 2:

輸入: k = 3, n = 9
輸出: [[1,2,6], [1,3,5], [2,3,4]]

💡 思路:

我們先把這道題抽象成樹:

抽象樹

接著套模板。

  • 終止條件

到葉子節點(path大小等於k)終止。

  • 返回值,引數

引數稍微有變化,序列是固定的,這裡的n是目標和;需要一個引數pathSum來記錄路徑上的數總和,我們直接全域性變數。

  • 單層邏輯

邏輯差別不大,回溯的時候需要把pathSum也回溯一下。

🖊 程式碼:

class Solution {
   //結果集合
    List<List<Integer>> result;
    //結果
    LinkedList<Integer> path;
    //結果綜合
    int pathSum;

    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backtrack(n, k, 1);
        return result;
    }
    
    //回溯
    public void backtrack(int n, int k, int start) {
        //結束
        if (path.size() == k) {
            if (pathSum == n) {
                result.add(new LinkedList<>(path));
            }
            return;
        }
        //遍歷序列
        for (int i = start; i <= 9; i++) {
            path.push(i);
            pathSum += i;
            //遞迴
            backtrack(n, k, i + 1);
            //回溯,撤銷操作
            pathSum -= path.pop();
        }
    }
}

⚡ 剪枝優化

同樣也可以進行剪枝優化,也很好想,如果pathNum>n ,那就沒必要再遍歷了。

class Solution {
   //結果集合
    List<List<Integer>> result;
    //結果
    LinkedList<Integer> path;
    //結果綜合
    int pathSum;

    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backtrack(n, k, 1);
        return result;
    }
    
    //回溯
    public void backtrack(int n, int k, int start) {
        //剪枝優化
        if (pathSum > n) {
            return;
        }
        //結束
        if (path.size() == k) {
            if (pathSum == n) {
                result.add(new LinkedList<>(path));
            }
            return;
        }
        //遍歷序列
        for (int i = start; i <= 9; i++) {
            path.push(i);
            pathSum += i;
            //遞迴
            backtrack(n, k, i + 1);
            //回溯,撤銷操作
            pathSum -= path.pop();
        }
    }
}

LeetCode39. 組合總和

☕ 題目:39. 組合總和 (https://leetcode-cn.com/problems/combination-sum/)

❓ 難度:中等

📕 描述:

給定一個無重複元素的正整數陣列 candidates 和一個正整數 target ,找出 candidates 中所有可以使數字和為目標數 target 的唯一組合。

candidates 中的數字可以無限制重複被選取。如果至少一個所選數字數量不同,則兩種組合是唯一的。

對於給定的輸入,保證和為 target 的唯一組合數少於 150 個。

示例 1:

輸入: candidates = [2,3,6,7], target = 7
輸出: [[7],[2,2,3]]

示例 2:

輸入: candidates = [2,3,5], target = 8
輸出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3:

輸入: candidates = [2], target = 1
輸出: []

示例 4:

輸入: candidates = [1], target = 1
輸出: [[1]]

示例 5:

輸入: candidates = [1], target = 2
輸出: [[1,1]]

提示:

  • 1 <= candidates.length <= 30
  • 1 <= candidates[i] <= 200
  • candidate 中的每個元素都是獨一無二的。
  • 1 <= target <= 500

💡 思路:

這道題和我們上面的有什麼區別呢?

它沒有數量要求,可以無限重複,但是有總和的限制。

組合總和

這裡有兩個關鍵點:

  • 元素可以重複使用
  • 組合不可重複

我們看看如何通過回溯三要素來carry:

  • 返回值&引數

引數裡需要start標明起點,為什麼呢?因為要求組合不重複,所以需要限制下次搜尋的起點,是基於本次選擇,這樣就不會選到本次選擇同層左邊的數。

  • 終止條件

這道題沒有限制數的個數,所以我們要根據pathSum>target(當前組合不滿足)和pathSum==target(當前組合滿足)來終止遞迴。

  • 單層邏輯

單層仍然從start開始,搜尋 candidates。

🖊 程式碼:

class Solution {
   //結果結合
    List<List<Integer>> result;
    //結果路徑
    LinkedList<Integer> path;
    //結果路徑值的和
    int pathSum;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        pathSum = 0;
        backtrack(candidates, target, 0);
        return result;
    }

    public void backtrack(int[] candidates, int target, int start) {
        //終止條件
        if (pathSum > target) return;
        if (pathSum == target) {
            result.add(new LinkedList<>(path));
        }
        for (int i = start; i < candidates.length; i++) {
            pathSum += candidates[i];
            path.push(candidates[i]);
            //注意,i不用加1,表示當前數可以重複讀取
            backtrack(candidates, target, i);
            //回溯
            pathSum -= path.pop();
        }
    }
}

⚡ 剪枝優化

又到了剪枝優化時間,在本層迴圈,如果發現下一層的pathSum(本層pathSum+candidates[i]),那麼就可以結束本層迴圈,注意要先把candidates拍一下序。

class Solution {
    //結果結合
    List<List<Integer>> result;
    //結果路徑
    LinkedList<Integer> path;
    //結果路徑值的和
    int pathSum;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        pathSum = 0;
        //剪枝優化,先排序
        Arrays.sort(candidates);
        backtrack(candidates, target, 0);
        return result;
    }

    public void backtrack(int[] candidates, int target, int start) {
        //終止條件
        if (pathSum > target) return;
        if (pathSum == target) {
            result.add(new LinkedList<>(path));
        }
       //剪枝優化,判斷迴圈之後的pathSum是否會超過target
        for (int i = start; i < candidates.length && pathSum + candidates[i] <= target; i++) {
            pathSum += candidates[i];
            path.push(candidates[i]);
            //注意,i不用加1,表示當前數可以重複讀取
            backtrack(candidates, target, i);
            //回溯
            pathSum -= path.pop();
        }
    }
}

LeetCode40. 組合總和 II

☕ 題目:40. 組合總和 II (https://leetcode-cn.com/problems/combination-sum-ii/)

❓ 難度:中等

📕 描述:

給定一個陣列 candidates 和一個目標數 target ,找出 candidates 中所有可以使數字和為 target 的組合。

candidates 中的每個數字在每個組合中只能使用一次。

注意:解集不能包含重複的組合。

示例 1:

輸入: candidates = [10,1,2,7,6,1,5], target = 8,
輸出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

輸入: candidates = [2,5,2,1,2], target = 5,
輸出:
[
[1,2,2],
[5]
]

提示:

  • 1 <= candidates.length <= 100
  • 1 <= candidates[i] <= 50
  • 1 <= target <= 30

💡 思路:

這道題和上一道題有啥區別呢?

  • candidates裡每個數字在每個組合裡只能使用一次
  • candidates裡的元素是有重複的

所以這道題的關鍵在於:集合(陣列candidates)有重複元素,但還不能有重複的組合

關於這個去重,有什麼思路呢?

  • 利用HashSet的特性去重,但是容易超時

  • 還有一種辦法,先把陣列排序[1,3,1] --> [1,1,3],我們比較一下相鄰的元素,重複的就跳過

我們把模擬樹畫一下:

模擬樹

三要素走起:

  • 返回值&引數

和上一道基本一致。

  • 終止條件
    • pathSum>target和pathSum==target。
    • 我們這次直接剪枝,提前判斷下次pathSum是否大於target,所以pathSum>target可以省略

🖊 程式碼:

class Solution {
      //結果集合
    List<List<Integer>> result;
    //結果路徑
    LinkedList<Integer> path;
    //結果路徑值總和
    int pathSum;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //排序condidates,去重前提
        Arrays.sort(candidates);
        //初始化相關變數
        result = new ArrayList<>();
        path = new LinkedList<>();
        pathSum = 0;
        backtrack(candidates, target, 0);
        return result;
    }

    public void backtrack(int[] candidates, int target, int start) {
        //終止條件
        if (pathSum == target) {
            result.add(new LinkedList<>(path));
            return;
        }
        //剪枝操作
        for (int i = start; i < candidates.length && candidates[i] + pathSum <= target; i++) {
            //同一層使用過的元素跳過
            if (i > start && candidates[i] == candidates[i - 1]) {
                continue;
            }
            pathSum += candidates[i];
            path.push(candidates[i]);
            //每個數字在每個組合中只能用一次,所以i++
            backtrack(candidates, target, i + 1);
            //回溯
            pathSum -= path.pop();
        }
    }
}

LeetCode17. 電話號碼的字母組合

☕ 題目:17. 電話號碼的字母組合(https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)

❓ 難度:中等

📕 描述:

給定一個僅包含數字 2-9 的字串,返回所有它能表示的字母組合。答案可以按 任意順序 返回。

給出數字到字母的對映如下(與電話按鍵相同)。注意 1 不對應任何字母。

17

示例 1:

輸入:digits = "23"
輸出:["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2:

輸入:digits = ""
輸出:[]

示例 3:

輸入:digits = "2"
輸出:["a","b","c"]

提示:

  • 0 <= digits.length <= 4
  • digits[i] 是範圍 ['2', '9'] 的一個數字。

💡 思路:

其實扒開表皮,這道題和77.組合本質上是一樣。只不過序列和組合個數沒有明確給出。

  • 序列是什麼:digits 對映成的字母序列
  • 組合個數:digits的大小

先畫抽象樹:

電話號碼的字母組合

🖊 程式碼:

class Solution {
    //結果集合
    List<String> result;
    //結果
    StringBuilder path;
    //每個路徑個數
    int pathNum;
    //對映陣列,0,1空出來,方便直接對映
    String[] numsMap = {" ", " ", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

    public List<String> letterCombinations(String digits) {
        result = new ArrayList<>();
        if (digits == null || digits.length() == 0) {
            return result;
        }
        path = new StringBuilder();
        pathNum = 0;
        backtrack(digits, pathNum);
        return result;
    }

    public void backtrack(String digits, int pathNum) {
        if (pathNum == digits.length()) {
            result.add(path.toString());
            return;
        }
        //獲取對映字母
        String letters = numsMap[digits.charAt(pathNum) - '0'];
        for (int i = 0; i < letters.length(); i++) {
            path.append(letters.charAt(i));
            //注意,pathNum+1,要處理下一層
            backtrack(digits, pathNum + 1);
            //回溯
            path.deleteCharAt(path.length() - 1);
        }
    }
}

分割問題

LeetCode131. 分割回文串

☕ 題目:131. 分割回文串 (https://leetcode-cn.com/problems/palindrome-partitioning/)

❓ 難度:中等

📕 描述:

給你一個字串 s,請你將 s 分割成一些子串,使每個子串都是 迴文串 。返回 s 所有可能的分割方案。

迴文串 是正著讀和反著讀都一樣的字串。

示例 1:

輸入:s = "aab"
輸出:[["a","a","b"],["aa","b"]]

示例 2:

輸入:s = "a"
輸出:[["a"]]

提示:

  • 1 <= s.length <= 16
  • s 僅由小寫英文字母組成

💡 思路:

我們寫了一些組合問題,現在又是一類新的問題——分割

但其實,分割問題,也類似組合。

例如對於字串abcdef:[1]

  • 組合問題:選取一個a之後,在bcdef中再去選取第二個,選取b之後在cdef中在選組第三個.....。
  • 切割問題:切割一個a之後,在bcdef中再去切割第二段,切割b之後在cdef中在切割第三段…….

先畫一下抽象樹:

分割回文串抽象樹

回溯三要素:

  • 引數

我們需要一個start來標記下一輪遞迴遍歷的起始位置。

  • 終止條件

如果start已經超過字串的長度,那麼說明我們path中的組合是迴文串。

  • 單層邏輯

單層邏輯和之前的邏輯大體類似,不過需要判斷一下字串是否是迴文串,這個比較簡單。

🖊 程式碼:

class Solution {
     List<List<String>> result;
    LinkedList<String> path;

    public List<List<String>> partition(String s) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backtrack(s, 0);
        return result;
    }

    public void backtrack(String s, int start) {
        //結束條件
        if (start >= s.length()) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = start; i < s.length(); i++) {
            //如果是迴文串
            if (isPalidrome(s, start, i)) {
                String r = s.substring(start, i+1);
                path.addLast(r);
            } else {
                continue;
            }
            //起始位置後移
            backtrack(s, i + 1);
            //回溯
            path.removeLast();
        }
    }

    //判斷是否迴文串
    boolean isPalidrome(String s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
}

LeetCode93. 復原 IP 地址

☕ 題目:93. 復原 IP 地址 (https://leetcode-cn.com/problems/restore-ip-addresses/)

❓ 難度:中等

📕 描述:

給定一個只包含數字的字串,用以表示一個 IP 地址,返回所有可能從 s 獲得的 有效 IP 地址 。你可以按任何順序返回答案。

有效 IP 地址 正好由四個整數(每個整數位於 0 到 255 之間組成,且不能含有前導 0),整數之間用 '.' 分隔。

例如:"0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址,但是 "0.011.255.245"、"192.168.1.312" 和 "[email protected]" 是 無效 IP 地址。

示例 1:

輸入:s = "25525511135"
輸出:["255.255.11.135","255.255.111.35"]

示例 2:

輸入:s = "0000"
輸出:["0.0.0.0"]

示例 3:

輸入:s = "1111"
輸出:["1.1.1.1"]

示例 4:

輸入:s = "010010"
輸出:["0.10.0.10","0.100.1.0"]

示例 5:

輸入:s = "101023"
輸出:["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示:

  • 0 <= s.length <= 3000
  • s 僅由數字組成

💡 思路:

這道題是不是和上一道題類似啊。

我們先把抽象樹畫一下:

復原ip地址抽象樹

分支比較多,偷懶省去了一些分支。

直接上回溯三要素:

  • 引數

因為ip為四段構成,所以我們需要一個引數來記錄段數,這裡用的是剩餘的段數residue

分割問題,需要標記start

  • 終止條件

終止條件是切割到了終點;

但是這道題又有段數的要求,所以還要加入段數的判斷。

  • 單層

單層裡面,除了回溯之類,我們還要判斷當前段是否滿足構成ip的要求。

🖊 程式碼:

class Solution {
    List<String> res = new ArrayList<>();
    Deque<String> path = new ArrayDeque<>(4);
    int len;

    public List<String> restoreIpAddresses(String s) {
        len = s.length();
        if (len > 12 || len < 4) return res;
        backtrack(s, 0, 4);
        return res;
    }

    /**
     *
     * @param s 字串
     * @param start 起始位置
     * @param residue 剩餘段數
     */
    private void backtrack(String s, int start, int residue) {
        //符合要求
        //字元已經用完,而且為四段
        if (start == len && residue == 0) {
            res.add(String.join(".", path));
            return;
        }
        for (int i = start; i < start + 3; i++) {
            if (i >= len) break;
            //減枝
            if (residue * 3 < len - i) continue;
            //只有符合要求的才加入
            if (isIpSegment(s, start, i)) {
                String currentIpSegment = s.substring(start, i + 1);
                path.addLast(currentIpSegment);
                backtrack(s, i + 1, residue - 1);
                //回溯
                path.removeLast();
            }
        }
    }

    //判斷字串是否符合ip要求
    private boolean isIpSegment(String s, int left, int right) {
        //首位0情況
        if (right - left + 1 > 1 && s.charAt(left) == '0') return false;
        //判斷對應數字是否滿足範圍
        int num = 0;
        for (int i = left; i <= right; i++) {
            num = num * 10 + s.charAt(i) - '0';
        }
        return num >= 0 && num <= 255;
    }
}

子集問題

LeetCode78. 子集

☕ 題目:78. 子集 (https://leetcode-cn.com/problems/subsets/)

❓ 難度:中等

📕 描述:

給你一個整數陣列 nums ,陣列中的元素 互不相同 。返回該陣列所有可能的子集(冪集)。

解集 不能 包含重複的子集。你可以按 任意順序 返回解集。

示例 1:

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

示例 2:

輸入:nums = [0]
輸出:[[],[0]]

提示:

  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10
  • nums 中的所有元素 互不相同

💡 思路:

這和我們前面做的 77.組合也是類似得。

先畫抽象樹結構:

子集

還是回溯三要素:

  • 引數

組合不重複,所以start標記起點

  • 終止條件

把陣列所有元素用完,就終止遞迴,也就是start走到了最後一個位置。

  • 單層邏輯

就一點需要注意,需要收集所有得組合。

🖊 程式碼:

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> subsets(int[] nums) {
        if (nums == null || nums.length == 0) {
            return result;
        }
        backstrck(nums, 0);
        return result;
    }

    public void backstrck(int[] nums, int start) {
        //放在最上面,否則漏掉本次
        result.add(new ArrayList<>(path));
        //終止條件
        if (start >=nums.length) {
            return;
        }
        for (int i = start; i <nums.length; i++) {
            path.addLast(nums[i]);
            backstrck(nums, i + 1);
            //回溯
            path.removeLast();
        }
    }
}

LeetCode90. 子集 II

☕ 題目:90. 子集 II (https://leetcode-cn.com/problems/subsets-ii/)

❓ 難度:中等

📕 描述:

給你一個整數陣列 nums ,其中可能包含重複元素,請你返回該陣列所有可能的子集(冪集)。

解集 不能 包含重複的子集。返回的解集中,子集可以按 任意順序 排列。

示例 1:

輸入:nums = [1,2,2]
輸出:[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2:

輸入:nums = [0]
輸出:[[],[0]]

提示:

  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10

💡 思路:

和上一道題有一點不一樣,nums裡面有重複的元素,而要保持組合的惟一,我們得想一個去重的辦法。

前面的40. 組合總和 II 還記得嗎?那道題裡序列裡同樣有重複的元素。

我們是怎麼去重的呢?先排序陣列,相鄰元素重複就跳過。

子集II抽象樹

🖊 程式碼:

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums == null || nums.length == 0) {
            result.add(new ArrayList<>());
            return result;
        }
        //先排序陣列
        Arrays.sort(nums);
        backtrack(nums, 0);
        return result;
    }

    public void backtrack(int[] nums, int start) {
        result.add(new ArrayList<>(path));
        //終止條件
        if (start >= nums.length) {
            return;
        }
        for (int i = start; i < nums.length; i++) {
            //先判斷是否重複
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }
            path.addLast(nums[i]);
            backtrack(nums, i + 1);
            //回溯
            path.removeLast();
        }
    }
}

LeetCode491. 遞增子序列

☕ 題目:491. 遞增子序列 (https://leetcode-cn.com/problems/increasing-subsequences/)

❓ 難度:中等

📕 描述:

給你一個整數陣列 nums ,找出並返回所有該陣列中不同的遞增子序列,遞增子序列中 至少有兩個元素 。你可以按 任意順序 返回答案。

陣列中可能含有重複元素,如出現兩個整數相等,也可以視作遞增序列的一種特殊情況。

示例 1:

輸入:nums = [4,6,7,7]
輸出:[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2:

輸入:nums = [4,4,3,2,1]
輸出:[[4,4]]

提示:

  • 1 <= nums.length <= 15
  • -100 <= nums[i] <= 100

💡 思路:

這道題乍一看,遞增?直接套90.子集II,當然,肯定是不行的。

注意啊,我們這個整數陣列是不能改變次序的,

所以上面我們用排序的方式去重在這裡用不上。

那怎麼辦呢?

我們需要用一個結構來儲存每一層用過的元素,來給它去重。

我們可以選擇用map來儲存用過的元素,來給每一層的迴圈去重。

遞增子序列-抽象樹

回溯三要素:

  • 引數

組合不重複,需要start。

  • 終止條件

遍歷完nums。

  • 單層邏輯
  1. 去重

用map儲存一層裡用過的元素,選擇元素之前,判斷元素是否用過。

  1. 遞增

每個元素和隊尾元素比一下,判斷是否滿足遞增的要求。

🖊 程式碼:

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList();

    public List<List<Integer>> findSubsequences(int[] nums) {
        if (nums == null || nums.length == 0) {
            result.add(new ArrayList<>());
            return result;
        }
        backtrack(nums, 0);
        return result;
    }

    public void backtrack(int[] nums, int start) {
        //使用map輔助去重
        Map<Integer, Integer> map = new HashMap<>();
        if (path.size() > 1) {
            result.add(new ArrayList<>(path));
        }
        if (start >= nums.length) {
            return;
        }
        for (int i = start; i < nums.length; i++) {
            //判斷當前元素序列是否遞增
            if (!path.isEmpty() && path.getLast() > nums[i]) {
                continue;
            }
            //本層迴圈元素已經用過,去重
            if (map.containsKey(nums[i])) {
                continue;
            }
            path.addLast(nums[i]);
            map.put(nums[i], i);
            backtrack(nums, i + 1);
            path.removeLast();
        }
    }
}

排列問題

LeetCode46. 全排列

☕ 題目:46. 全排列 (https://leetcode-cn.com/problems/permutations/)

❓ 難度:中等

📕 描述:

給定一個不含重複數字的陣列 nums ,返回其 所有可能的全排列 。你可以 按任意順序 返回答案。

示例 1:

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

示例 2:

輸入:nums = [0,1]
輸出:[[0,1],[1,0]]

示例 3:

輸入:nums = [1]
輸出:[[1]]

提示:

  • 1 <= nums.length <= 6
  • -10 <= nums[i] <= 10
  • nums 中的所有整數 互不相同

💡 思路:

這裡注意,我們在每一層去重。

我們之前用過兩種方法去重:排序去重map去重

這用一個新的辦法,用一個boolean陣列used標記元素是否被用過。

先畫抽象樹:

全排列

回溯三部曲:

  • 結束條件

path中取到了等於集合得數量.

  • 引數

注意啊,因為這裡要從頭開始搜尋,所以就不用start了;

我們去重用的used陣列直接定義全域性變數;

  • 單層邏輯

需要根據used陣列判斷當前元素是否用過。

🖊 程式碼:

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;

    public List<List<Integer>> permute(int[] nums) {
        if (nums == null || nums.length == 0) {
            result.add(path);
            return result;
        }
        used = new boolean[nums.length];
        backtrack(nums);
        return result;
    }

    public void backtrack(int[] nums) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            //去重判斷
            if (used[i]) {
                continue;
            }
            //標記用過
            used[i] = true;
            path.addLast(nums[i]);
            backtrack(nums);
            //回溯
            used[i] = false;
            path.removeLast();
        }
    }
}

LeetCode47. 全排列 II

☕ 題目:47. 全排列 II (https://leetcode-cn.com/problems/permutations-ii/)

❓ 難度:中等

📕 描述:

給定一個可包含重複數字的序列 nums ,按任意順序 返回所有不重複的全排列。

示例 1:

輸入:nums = [1,1,2]
輸出:
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2:

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

提示:

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

💡 思路:

這道題在上一道題的基礎上:給定一個可包含重複數字的序列 nums

又到了我們喜聞樂見的去重時間,這個去重是單層的去重。

這次我們可以使用排序,相鄰元素比較的方式去重。

先畫抽象樹:

全排列II

🖊 程式碼:

class Solution {
     List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;

    public List<List<Integer>> permuteUnique(int[] nums) {
        if (nums == null || nums.length == 0) {
            result.add(path);
            return result;
        }
        //排序無序集合
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backtrack(nums);
        return result;
    }

    public void backtrack(int[] nums) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            //判斷元素本層是否用過
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //判斷元素本枝幹是否用過
            if (used[i]) {
                continue;
            }
            //開始處理
            //標記同一個枝幹用過
            used[i] = true;
            path.addLast(nums[i]);
            backtrack(nums);
            //回溯
            path.removeLast();
            used[i] = false;
        }
    }
}

棋盤問題

LeetCode51. N 皇后

☕ 題目:51. N 皇后 (https://leetcode-cn.com/problems/n-queens/)

❓ 難度:困難

📕 描述:

n 皇后問題 研究的是如何將 n 個皇后放置在 n×n 的棋盤上,並且使皇后彼此之間不能相互攻擊。

給你一個整數 n ,返回所有不同的 n 皇后問題 的解決方案。

每一種解法包含一個不同的 n 皇后問題 的棋子放置方案,該方案中 'Q' 和 '.' 分別代表了皇后和空位。

示例 1:

N皇后

輸入:n = 4
輸出:[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解釋:如上圖所示,4 皇后問題存在兩個不同的解法。

示例 2:

輸入:n = 1
輸出:[["Q"]]

提示:

  • 1 <= n <= 9
  • 皇后彼此不能相互攻擊,也就是說:任何兩個皇后都不能處於同一條橫行、縱行或斜線上。

💡 思路:

首先看一下,每個組合又什麼限制呢?

  • 不能同行
  • 不能同列
  • 不能在同一條斜線

搜尋皇后的位置,同樣可以抽象成一棵樹。

N皇后

矩陣的高就是樹的高度,矩陣的寬就是每一個節點的寬度。

我們拿皇后的約束條件來剪枝,只要能搜尋到樹的葉子節點,那麼就說明找到和合適的位置。

回溯三要素上吧!

  • 引數

需要一個二維陣列表示棋盤;

引數n記錄棋盤大小;

用row記錄遍歷到棋盤的第幾層;

  • 終止條件

到了最底的一層,說明找到合適的皇后的位置;

  • 單層邏輯

需要判斷當前選擇是否符合N皇后約束條件;

三個條件,行不用管,因為我們是一行一行往下的。

只需要判斷左上角斜方向,列方向,右上角斜方向。

判斷N皇后條件

🖊 程式碼:

class Solution {
     List<List<String>> result = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        //棋盤
        char[][] board = new char[n][n];
        //初始化棋盤
        for (char[] c : board) {
            Arrays.fill(c, '.');
        }
        backtrack(board, n, 0);
        return result;
    }

    public void backtrack(char[][] board, int n, int row) {
        //終止條件,到底了
        if (row == n) {
            result.add(arrayToList(board));
            return;
        }
        for (int col = 0; col < n; col++) {
            //判斷是否符合N皇后要求
            if (!isValid(board, n, row, col)) continue;
            //開始操作
            board[row][col] = 'Q';
            backtrack(board, n, row + 1);
            //回溯
            board[row][col] = '.';
        }
    }

    //判斷當前位置是否滿足N皇后要求
    public boolean isValid(char[][] board, int n, int row, int col) {
        //行不用判斷,每層只有一個
        //col列判斷
        for (int k = 0; k < n; k++) {
            if (board[k][col] == 'Q') {
                return false;
            }
        }
        //檢查主對角線(45度)
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] == 'Q') {
                return false;
            }
        }
        //檢查副對角線(135度)
        for (int i = row - 1, j = col + 1; i >= 0 && j <= n - 1; i--, j++) {
            if (board[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }

    //將棋盤陣列轉換為字串列表
    public List<String> arrayToList(char[][] board) {
        List<String> path = new ArrayList<>();
        for (char[] c : board) {
            path.add(String.valueOf(c));
        }
        return path;
    }
}

LeetCode 37. 解數獨

☕ 題目:37. 解數獨(https://leetcode-cn.com/problems/sudoku-solver/)

❓ 難度:困難

📕 描述:

編寫一個程式,通過填充空格來解決數獨問題。

數獨的解法需 遵循如下規則:

  • 數字 1-9 在每一行只能出現一次。
  • 數字 1-9 在每一列只能出現一次。
  • 數字 1-9 在每一個以粗實線分隔的 3x3 宮內只能出現一次。(請參考示例圖)

數獨部分空格內已填入了數字,空白格用 '.' 表示。

img

輸入:board = [["5","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
[".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]]

輸出:[["5","3","4","6","7","8","9","1","2"],
["6","7","2","1","9","5","3","4","8"],
["1","9","8","3","4","2","5","6","7"],
["8","5","9","7","6","1","4","2","3"],
["4","2","6","8","5","3","7","9","1"],
["7","1","3","9","2","4","8","5","6"],
["9","6","1","5","3","7","2","8","4"],
["2","8","7","4","1","9","6","3","5"],
["3","4","5","2","8","6","1","7","9"]]

解釋:輸入的數獨如上圖所示,唯一有效的解決方案如下所示:

img

提示:

  • board.length == 9
  • board[i].length == 9
  • board[i][j] 是一位數字或者 '.'
  • 題目資料 保證 輸入數獨僅有一個解

💡 思路:

這道題可以說是N皇后問題的plu版本了。

這道題矩陣的長度和寬度都比N皇后更長更寬。

而且判斷重複也更難:

  • 同行是否重複
  • 同列是否重複
  • 9宮格里是否重複

我們先大概畫一棵抽象樹:

數獨抽象樹

這個圖畫起來太麻煩了,差不多就那個意思,接下來我們三部曲走起[1]。

  • 返回值與引數

因為解數獨找到一個符合的條件就返回,所以返回值用boolean型別。

  • 終止條件

可以不用終止條件,因為

  • 單層邏輯

需要一個兩個迴圈套著的遞迴,一個迴圈棋盤的行,一個迴圈棋盤的列,遞迴遍歷這個位置放9個數字的可能。

🖊 程式碼:

class Solution {
    public void solveSudoku(char[][] board) {
        backtrack(board);
    }

    boolean backtrack(char[][] board) {
        //遍歷行
        for (int row = 0; row < board.length; row++) {
            //遍歷列
            for (int col = 0; col < board[0].length; col++) {
                if (board[row][col] != '.') continue;
                //嘗試1-9
                for (char k = '1'; k <= '9'; k++) {
                    //不滿足,跳過
                    if (!isValid(board, row, col, k)) continue;
                    //滿足要求操作
                    board[row][col] = k;
                    //找到一組,立即返回
                    if (backtrack(board)) {
                        return true;
                    }
                    //回溯,撤銷填入
                    board[row][col] = '.';
                }
                //9個數試完了,不行,返回false
                return false;
            }
        }
        return true;
    }

    //判斷是否符合數獨要求
    boolean isValid(char[][] board, int row, int col, char val) {
        //判斷行是否重複
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == val) {
                return false;
            }
        }
        //判斷列是否重複
        for (int j = 0; j < 9; j++) {
            if (board[j][col] == val) {
                return false;
            }
        }
        //判斷小9宮格是否重複
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++) {
            for (int j = startCol; j < startCol + 3; j++) {
                if (board[i][j] == val) {
                    return false;
                }
            }
        }
        return true;
    }
}

總結

接著順口溜總結:

總結


簡單的事情重複做,重複的事情認真做,認真的事情有創造性地做。

點贊關注收藏一鍵三連,鼓勵我繼續輸出精彩博文!


參考:

[1]. https://github.com/youngyangyang04/leetcode-master

[2]. https://labuladong.gitbook.io

[3]. https://leetcode-cn.com/problems/restore-ip-addresses/solution/hui-su-suan-fa-hua-tu-fen-xi-jian-zhi-tiao-jian-by/