46. Permutations

问题：

给定一个数组，求对该数组进行全排列的所有结果。

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.

　　

解法：Backtracking（回溯算法）DFS（深度优先搜索 Depth-First-Search）

回溯算法框架：

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return

    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

对于本问题，两个变量：

• 路径：已经选择好的前几位结果
• 选择列表：对每个位置上元素的选择可能性

处理过程：

• base：递归退出条件：选择到最后一位结束，这里为已经选择好路径长度==给出的数组长度。
• 做选择：对于当前位置，选择其中一个可用数字a。
  • 路径.add(a)
  • 选择列表.delete(a)
• 撤销选择：回退到选择数字a之前的状况。
  • 路径.delete(a)
  • 选择列表.add(a)

代码参考：

class Solution {
public:
    void traverse(vector<int> path, vector<int> nums) {
        if(nums.empty()) {
            result.push_back(path);
            return;
        }
        for(int i=0; i<nums.size(); i++) {
            vector<int> numstmp(nums);
            path.push_back(nums[i]);
            numstmp.erase(numstmp.begin()+i);
            traverse(path, numstmp);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<int> path;
        traverse(path, nums);
        return result;
    }
private:
    vector<vector<int>> result;
};

改进：

每次新建numstmp，太耗费内存，

-> 在做选择的时候，path中如果已经存在【选择列表】中的元素。说明该元素已被占用，则continue，不进行尝试。

要判断是否存在，vector中没有很好的方法，因此，引入unordered_set 等同path所存储内容。

使用count方法进行判断是否存在。

代码参考：

class Solution {
public:
    void traverse(vector<int> path, vector<int> nums, unordered_set<int> pathset) {
        if(path.size()==nums.size()) {
            result.push_back(path);
            return;
        }
        for(int i=0; i<nums.size(); i++) {
            if(pathset.count(nums[i])!=0) continue;
            path.push_back(nums[i]);
            pathset.insert(nums[i]);
            traverse(path, nums, pathset);
            path.pop_back();
            pathset.erase(nums[i]);
        }
        return;
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<int> path;
        unordered_set<int> pathset;
        traverse(path, nums, pathset);
        return result;
    }
private:
    vector<vector<int>> result;
};

改进：swap方法

 对给定数组，进行元素交换，所得数组即为一个解。

class Solution {
public:
    void traverse(vector<int> nums, int pos) {
        if(pos==nums.size()) {
            result.push_back(nums);
            return;
        }
        for(int i=pos; i<nums.size(); i++) {
            swap(nums[i], nums[pos]);
            traverse(nums, pos+1);
            swap(nums[i], nums[pos]);
        }
        return;
    }
    vector<vector<int>> permute(vector<int>& nums) {
        traverse(nums, 0);
        return result;
    }
private:
    vector<vector<int>> result;
};