相關：46. Permutations

問題：給定（存在重複元素）的陣列，進行全排列，求出所有排列的可能性。

Example 1:
Input: nums = [1,1,2]
Output:
[[1,1,2],
 [1,2,1],
 [2,1,1]]

Example 2:
Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
 
Constraints:
1 <= nums.length <= 8
-10 <= nums[i] <= 10

解法：Backtracking（回溯演算法）

兩個變數：

• 路徑path：已經選擇好的前幾位結果
• 選擇列表：當前位置上元素的選擇可能性：nums-visited
• visited標記排除已經被選擇過的元素。
• nums所有元素。

處理過程：

base：遞迴退出條件：選擇到最後一位結束，這裡為已經選擇好路徑長度==給出的陣列長度。

做選擇：對於當前位置，選擇其中一個可用數字a。

• • 路徑.add(a)
  • 選擇列表.delete(a)->visited[i]=1

撤銷選擇：回退到選擇數字a之前的狀況。

• • 路徑.delete(a)
  • 選擇列表.add(a)->visited[i]=0

⚠️ 注意：本問題中，允許存在相同的元素，但是在排列中，相同元素在同一位置上的選擇，是無效的。

因此，我們需要排除相同元素在同一個位置上的選擇。

• 首先對nums進行排列，相同元素則會被連續排列。
• 從第二個重複的元素開始，在同一個位置上的選擇：
  • 若當前path中該重複的第一個元素已被使用，則當前的排序為全新排列，沒有問題。
  • 若第一元素沒有被使用visited[i-1]==0，則現在選擇該重複元素，一定和之前的path選擇中該位置使用了第一個元素的排列發生重複，需要跳過。

程式碼參考：

 1 class Solution {
 2 public:
 3     void traverse(vector<vector<int>>& res, vector<int
 
> nums, vector<int>& path, vector<int>& visited) {
 4         if(path.size() == nums.size()) {
 5             res.push_back(path);
 6             return;
 7         }
 8         for(int i = 0; i < nums.size(); i++) {
 9             if(visited[i]) continue;
10             //該元素nums[i]已被使用在目前的path中，則跳過。
11             if(i!=0 && nums[i]==nums[i-1] && !visited[i-1]) continue;
12             //該元素nums[i]，與還沒被目前的path中使用的，排在它之前的元素重複，
13             //（說明，上一個path的構造中，在同一個位置，一定已經使用過排在它之前的元素），則跳過。
14             visited[i] = 1;
15             path.push_back(nums[i]);
16             traverse(res, nums, path, visited);
17             path.pop_back();
18             visited[i] = 0;
19         }
20         return;
21     }
22     vector<vector<int>> permuteUnique(vector<int>& nums) {
23         vector<vector<int>> res;
24         vector<int> path;
25         vector<int> visited(nums.size(), 0);
26         sort(nums.begin(), nums.end());
27         traverse(res, nums, path, visited);
28         return res;
29     }
30 };

另，swap方法：

參考：leetcode說明

swap不需要恢復位置。與遞迴呼叫中重複元素的排除有關。

程式碼參考：

 1 class Solution {
 2 public:
 3     void traverse(vector<vector<int>>& res, vector<int> nums, int pos) {
 4         if(pos == nums.size()) {
 5             res.push_back(nums);
 6             return;
 7         }
 8         for(int i = pos; i < nums.size(); i++) {
 9             if(i!=pos && nums[i]==nums[pos]) continue;
10             swap(nums[i], nums[pos]);
11             traverse(res, nums, pos+1);
12         }
13         return;
14     }
15     vector<vector<int>> permuteUnique(vector<int>& nums) {
16         vector<vector<int>> res;
17         sort(nums.begin(), nums.end());
18         traverse(res, nums, 0);
19         return res;
20     }
21 };