《LeetCode之每日一题》:191.全排列

题目链接： 全排列

有关题目

给定一个不含重复数字的数组 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 中的所有整数 互不相同

题解

法一：回溯 + 标记数组

class Solution {
public:

    void backtrack(vector<vector<int>> &ans, int cnt, vector<int> &num, vector<int> &nums, vector<bool> used)
    {
        if (cnt == nums.size())
        {
            ans.push_back(num);
            return ;
        }

        for (int i = 0; i < nums.size(); i++)
        {
            if (!used[i])
            {
                num.push_back(nums[i]);
                used[i] = true;
                backtrack(ans, cnt + 1, num, nums, used);
                num.pop_back();
                used[i] = false;
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> ans;
        vector<bool> used(n);
        vector<int> num;
        backtrack(ans, 0, num, nums, used);

        return ans;
    }
};

空间复杂度：O(n)，答案返回数组不计，递归调用n 层，开辟数组长度为n的额外数组used, num，总计O(3 * n),故空间复杂度为O(n)

法二：回溯 + 动态数组
参考官方题解

class Solution {
public:

    void backtrack(vector<vector<int>> &ans, vector<int> &nums, int first, int len)
    {
    	//函数功能是用回溯的方法，将满足len长度所有排列放入到数组ans
    	
        if (first == len)//所有数字填写完毕
        {
            ans.push_back(nums);
            return ;
        }

        for (int i = first; i < len; i++)
        {
            swap(nums[i], nums[first]);// 动态维护数组
            backtrack(ans, nums, first + 1, len);//递归填写下一个数字
            swap(nums[i], nums[first]);//撤销操作
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        backtrack(ans, nums, 0, (int)nums.size());

        return ans;
    }
};