Leetcode—46.全排列【中等】

2023每日刷题（六十六）

Leetcode—46.全排列

算法思想

对于排列来说，我们需要考虑数字之间的相对顺序，不同的相对顺序会产生不同的排列方式。此外，序列中的每个数字一定存在于每个排列当中。因此，不能依次考虑每个数字的状态。换个角度来思考，可以依次考虑排列中的每一个位置，对于每个位置来说，它可能是序列中的任意一个数字，因此可以在整个递归深入的过程中依次考虑每个位置上的所有可能性。

为了使每个数字只被使用一次，还需要通过无序集合visited来记录上层递归路径中加入的数字，若数字存在于visited中则忽略。

实现代码

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        int n = nums.size();
        vector<int> path(n);
        vector<bool> visited(n);
        function<void(int)> dfs = [&](int i) {
            if(i == n) {
                ans.emplace_back(path);
                return;
            }
            for(int j = 0; j < n; j++) {
                if(!visited[j]) {
                    path[i] = nums[j];
                    visited[j] = true;
                    dfs(i + 1);
                    visited[j] = false;
                }
            }
        };
        dfs(0);
        return ans;
    }
};

运行结果

另一种算法思想

实现代码

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        int n = nums.size();
        function<void(int)> dfs = [&](int x) {
            if(x == n - 1) {
                ans.emplace_back(nums);
                return;
            }
            for(int i = x; i < n; i++) {
                swap(nums[i], nums[x]);
                dfs(x + 1);
                swap(nums[i], nums[x]);
            }
        };
        dfs(0);
        return ans;
    }
};

运行结果

2024.5.15重温一遍

回溯实现代码

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        int n = nums.size();
        vector<bool>visited(n, false);
        vector<int> path(n);
        function<void(int)> dfs = [&](int i) {
            if(i == n) {
                ans.emplace_back(path);
                return;
            }

            for(int j = 0; j < n; j++) {
                if(visited[j]) {
                    continue;
                }
                visited[j] = true;
                path[i] = nums[j];
                dfs(i + 1);
                visited[j] = false;
            }
        };
        dfs(0);
        return ans;
    }
};

运行结果

swap算法实现代码

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        int n = nums.size();
        function<void(int)> dfs = [&](int i) {
            if(i == n - 1) {
                ans.emplace_back(nums);
                return;
            }

            for(int x = i; x < n; x++) {
                swap(nums[x], nums[i]);
                dfs(i + 1);
                swap(nums[x], nums[i]);
            }
        };
        dfs(0);
        return ans;
    }
};

运行结果

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！