LeetCode中回溯法的一些題總結

最近刷LeetCode（慚愧，前兩頁還沒刷完···）發現在好多問題中都碰到了回溯法，並且有一個固定的模板。於是想試著總結一下，並加深記憶，希望以後碰到類似的問題能信手拈來~
利用回溯的題目，比較好識別，特點就是需要窮舉才能得到答案。所以肯定是需要遞迴的。（吐槽一下自己，樹的問題基本都需要遞迴，我每次碰到都要想半天···）
話不多說，上題：

• LeetCode46 全排列
  給定一個沒有重複數字的序列，返回其所有可能的全排列。
  示例：

輸入：[1,2,3]
輸出：
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
 

程式碼：

class Solution{
	public List<List<Integer>> permute(int[] nums){
		List<List<Integer>> res = new ArrayList<>();
		backtrack(res, new ArrayList<>(), nums);
		return res;
	}
	public void backtrack(List<List<Integer>> res, List<Integer> list,
 
 int[]nums){
		if(list.size() == nums.length){
			res.add(new ArrayList<>(list));
		} else {
			for(int i = 0; i < nums.length; i++){
				if(list.contains(nums[i])){
					continue;
				}
				list.add(nums[i]);
				backtrack(res, list, nums);
				list.remove(list.size()-1);
			}
		}
	}
}

• LeetCode 47 給定一個可包含重複數字的排列，返回所有不重複的全排列
  示例：

輸入：[1,1,2]
輸出：
[
[1,1,2],
[1,2,1],
[2,1,1]
]

和上面的題相比，除了回溯外，為了不引入重複項，需要進行剪枝操作.因此，我們引入一個標記是否被訪問過的變數。

圖片來自微信公眾號Leetcode名企之路
下面是程式碼

class Solution{
	public List<List<Integer>> permuteUnique(int[] nums){
		List<List<Integer>> res = new ArrayList<>();
		Arrays.sort(nums);
		boolean[] used = new boolean[nums.length];//標記是否被訪問過
		backtrack(res, new ArrayList<>(), nums, used);
		return res;
	}
	public void backtrack(List<List<Integer>> res, List<Integer> list, int[] nums, boolean[] used){
		if(list.size() == nums.length){
			res.add(new ArrayList<>(list));
		} else {
			for(int i = 0; i < nums.length; i++){
				if(used[i]) continue;
				if(i > 0 && nums[i-1] == nums[i] && !used[i - 1]) continue;
				used[i] = true;
				list.add(nums[i]);
				backtrack(res, list, nums, used);
				used[i] = false;
				list.remove(list.size()-1);
			}
		}
	}
}

• LeetCode77 組合
  給定兩個整數n和k，返回1~n中所有可能的k個數的組合
  示例：

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

直接上程式碼

class Solution{
	public List<List<Integer>> combine(int n, int k){
		List<List<Integer>> res = new ArrayList<>();
		backtrack(res, new ArrayList<>(), n, k, 1);
		return res;
	}
	public void backtrack(List<List<Integer>> res, List<Integer> list, int n, int k, int start){
		if(list.size() == k){
			res.add(new ArrayList<>(list));
		} else{
			for(int i = start; i <= n; i++){
				list.add(i);
				backtrack(res, list, n, k, i+1);
				list.remove(list.size()-1);
			}
		}
	}
}

• LeetCode78 子集
  
  程式碼

class Solution{
	public List<List<Integer>> subsets(int[] nums){
		List<List<Integer>> res = new ArrayList<>();
		Arrays.sort(nums);
		backtrack(res, new ArrayList<>(), nums, 0);
		return res;
	}
	public void backtrack(List<List<Integer>> res, List<Integer> list, int[] nums, int start){
		res.add(new ArrayList<>(list));
		for(int i = start; i < nums.length; i++){
			list.add(nums[i]);
			backtrack(res,list,nums,i+1);
			list.remove(list.size()-1);
		}
	}
}

全排列和子集的區別：全排列的話需要約束每一項的元素個數，而且for迴圈裡永遠是從0開始的；子集不需要約束元素個數，因此每個解都要加入到最終解集中去，為了防止重複項，需要設定一個start，標記每次回溯從哪裡開始。

程式碼和圖參考公眾號LeetCode名企之路，安利一波。