Topic
- Backtracking
Description
https://leetcode.com/problems/permutations/
Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.
Example 1:
Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
Example 2:
Input: nums = [0,1]
Output: [[0,1],[1,0]]
Example 3:
Input: nums = [1]
Output: [[1]]
Constraints:
- 1 <= nums.length <= 6
- -10 <= nums[i] <= 10
- All the integers of nums are unique.
Analysis
方法一：回溯算法（不使用startIndex）
思路分析
以[1,2,3]爲例，抽象成樹形結構如下：
回溯三弄
遞歸函數參數
首先排列是有序的，也就是說[1,2] 和[2,1] 是兩個集合，這和之前分析的子集以及組合所不同的地方。
可以看出元素1在[1,2]中已經使用過了，但是在[2,1]中還要在使用一次1，所以處理這裏不用使用startIndex了。
但本問題需要一個used數組，標記已經選擇的元素，如思路分析圖橘黃色部分所示。
代碼如下：
private void backtracking(List<Integer> path, int[] nums, boolean[] used, List<List<Integer>> results) {}
遞歸終止條件
可以看出葉子節點，就是收割結果的地方。
當收集元素的數組path的大小達到和nums數組一樣大的時候，說明找到了一個全排列，也表示到達了葉子節點。
if (path.size() == nums.length) {
results.add(new ArrayList<>(path));
return;
}
單層搜索邏輯
代碼如下：
for (int i = 0; i < nums.length; i++) {
if (used[i])
continue;
used[i] = true;
path.add(nums[i]);
backtracking(path, nums, used, results);
path.remove(path.size() - 1);
used[i] = false;
}
方法二：回溯算法2（使用startIndex）
同方法一差異不大，不過用到startIndex和數組交換元素。
參考資料
Submission
import java.util.ArrayList;
import java.util.List;
public class Permutations {
// 方法一：回溯算法
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> results = new ArrayList<>();
List<Integer> path = new ArrayList<>();
boolean[] used = new boolean[nums.length];
backtracking(path, nums, used, results);
return results;
}
private void backtracking(List<Integer> path, int[] nums, boolean[] used, List<List<Integer>> results) {
if (path.size() == nums.length) {
results.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
if (used[i])
continue;
used[i] = true;
path.add(nums[i]);
backtracking(path, nums, used, results);
path.remove(path.size() - 1);
used[i] = false;
}
}
// 方法二：回溯算法2
public List<List<Integer>> permute2(int[] nums) {
List<List<Integer>> results = new ArrayList<>();
List<Integer> path = new ArrayList<>();
backtracking2(path, 0, nums, results);
return results;
}
private void backtracking2(List<Integer> path, int startIndex, //
int[] array, List<List<Integer>> results) {
if (startIndex == array.length) {
results.add(new ArrayList<>(path));
return;
}
for (int i = startIndex; i < array.length; i++) {
swap(array, startIndex, i);
path.add(array[startIndex]);
backtracking2(path, startIndex + 1, array, results);
path.remove(path.size() - 1);
swap(array, startIndex, i);
}
}
private void swap(int[] num, int i, int j) {
int temp = num[i];
num[i] = num[j];
num[j] = temp;
}
}
Test
import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.List;
import static org.hamcrest.collection.IsIterableContainingInAnyOrder.*;
import org.hamcrest.Matcher;
import org.junit.Test;
@SuppressWarnings("unchecked")
public class PermutationsTest {
private final Permutations obj = new Permutations();
private final int[] array = {1, 2, 3};
private final Matcher<Iterable<? extends List<Integer>>> expected = containsInAnyOrder(Arrays.asList(1, 2, 3), //
Arrays.asList(1, 3, 2), Arrays.asList(2, 1, 3), Arrays.asList(2, 3, 1),//
Arrays.asList(3, 1, 2), Arrays.asList(3, 2, 1));
private final int[] array2 = {0, 1};
private final Matcher<Iterable<? extends List<Integer>>> expected2 = containsInAnyOrder(Arrays.asList(0, 1), Arrays.asList(1, 0));
private final int[] array3 = {1};
private final Matcher<Iterable<? extends List<Integer>>> expected3 = containsInAnyOrder(Arrays.asList(1));
@Test
public void test() {
assertThat(obj.permute(array), expected);
assertThat(obj.permute(array2), expected2);
assertThat(obj.permute(array3), expected3);
}
@Test
public void test2() {
assertThat(obj.permute2(array), expected);
assertThat(obj.permute2(array2), expected2);
assertThat(obj.permute2(array3), expected3);
}
}