大家好，我是被演算法題虐到淚流滿面的老三，只能靠發發文章給自己打氣！
這一節，我們來看看回溯演算法。
回溯演算法理論基礎
什麼是回溯
在二叉樹的路徑問題裡，其實我們已經接觸到了回溯這種演算法。
例如我們在查詢二叉樹所有路徑的時候，查詢完一個路徑之後，還需要回退，接著找下一個路徑。
回溯其實可以說是我們熟悉的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/)
難度：中等
描述：
給定兩個整數 n 和 k，返回範圍 [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，說明到了葉子節點，一次遞迴結束。
- 單層邏輯
在單層邏輯裡面，我們要做兩件事：
- 遍歷序列
- 遞迴，遍歷節點
程式碼：
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迴圈選擇的起始位置之後的元素個數 已經不足 我們需要的元素個數了，那麼就沒有必要搜尋。
- 已經選擇的元素個數：path.size();
- 還需要的元素個數為: k - path.size();
- 所以起始位置 : 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 不對應任何字母。
示例 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為四段構成，所以我們需要一個引數來記錄段數，這裡用的是剩餘的段數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 還記得嗎？那道題裡序列裡同樣有重複的元素。
我們是怎麼去重的呢？先排序陣列，相鄰元素重複就跳過。
程式碼：
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。
- 單層邏輯
- 去重
用map儲存一層裡用過的元素，選擇元素之前，判斷元素是否用過。
- 遞增
每個元素和隊尾元素比一下，判斷是否滿足遞增的要求。
程式碼：
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。
又到了我們喜聞樂見的去重時間，這個去重是單層的去重。
這次我們可以使用排序，相鄰元素比較的方式去重。
先畫抽象樹：
程式碼：
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 = 4
輸出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解釋：如上圖所示，4 皇后問題存在兩個不同的解法。
示例 2：
輸入：n = 1
輸出：[["Q"]]
提示：
1 <= n <= 9- 皇后彼此不能相互攻擊，也就是說：任何兩個皇后都不能處於同一條橫行、縱行或斜線上。
思路：
首先看一下，每個組合又什麼限制呢？
- 不能同行
- 不能同列
- 不能在同一條斜線
搜尋皇后的位置，同樣可以抽象成一棵樹。
矩陣的高就是樹的高度，矩陣的寬就是每一個節點的寬度。
我們拿皇后的約束條件來剪枝，只要能搜尋到樹的葉子節點，那麼就說明找到和合適的位置。
回溯三要素上吧！
- 引數
需要一個二維陣列表示棋盤；
引數n記錄棋盤大小；
用row記錄遍歷到棋盤的第幾層；
- 終止條件
到了最底的一層，說明找到合適的皇后的位置；
- 單層邏輯
需要判斷當前選擇是否符合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 宮內只能出現一次。（請參考示例圖）
數獨部分空格內已填入了數字，空白格用 '.' 表示。
輸入：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"]]解釋：輸入的數獨如上圖所示，唯一有效的解決方案如下所示：
提示：
- 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