【算法总结】排列组合的序列产生问题

1. Next Permutation

　　首先，从最尾端开始往前寻找两个相邻元素，令第一元素为 *i，第二元素为 *ii，且满足 *i < *ii；找到这样一组相邻元素后，再从尾端开始往前检验，找出第一个大于 *i 的元素，令为 *j，将 i，j 元素对调，再将 ii 之后的所有元素颠倒排列。

void nextPermutation(vector<int>& nums) {
        if(nums.empty())
            return;
        int n = nums.size();
        for (int i = n - 2; i >=0; --i) {
            if (nums[i] >= nums[i + 1])
                continue;
            int j = n - 1;
            while (j >= 0 && nums[j] <= nums[i]) --j;
            swap(nums[i], nums[j]);
            reverse(nums.begin() + i + 1, nums.end());
            return;
        }
        // 进行至最前面，重排
        reverse(nums.begin(), nums.end());
    }

 

2.Prev Permutation

　　首先，从最尾端开始往前寻找两个相邻元素，令第一元素为 *i，第二元素为 *ii，且满足 *i  > *ii；找到这样一组相邻元素后，再从尾端开始往前检验，找出第一个小于*i 的元素，令为 *j，将 i，j 元素对调，再将 ii 之后的所有元素颠倒排列。

void prevPermutation(vector<int>& nums) {
        if(nums.empty())
            return;
        int n = nums.size();
        for (int i = n - 2; i >=0; --i) {
            if (nums[i] <= nums[i + 1])
                continue;
            int j = n - 1;
            while (j >= 0 && nums[j] >= nums[i]) --j;
            swap(nums[i], nums[j]);
            reverse(nums.begin() + i + 1, nums.end());
            return;
        }
        reverse(nums.begin(), nums.end());
    }

 

3. Permutations（全排列）

 　　（1）回溯法

vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> cur;
        vector<bool> visited(nums.size(), false);
        
        dfs(nums, res, cur, visited);
        
        return res;
    }
    
    void dfs(const vector<int>& nums, vector<vector<int>>& res, vector<int>& cur, vector<bool>& visited) {
        if (cur.size() == nums.size()) {
            res.push_back(cur);
            return;
        }
        
        for (int i = 0; i < nums.size(); ++i) {
            if (visited[i] == false) {
                cur.push_back(nums[i]);
                visited[i] = true;
                dfs(nums, res, cur, visited);
                cur.pop_back();
                visited[i] = false;
            }
        }
    }

　　（2）递归 1：

vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        
        recursive(nums, res, 0);
        
        return res;
    }
    
    void recursive(vector<int>& nums, vector<vector<int>>& res, int start) {
        if (start >= nums.size()) {
            res.push_back(nums);
        }
        for (int i = start; i < nums.size(); ++i) {
            swap(nums[start], nums[i]);
            recursive(nums, res, start + 1);
            swap(nums[start], nums[i]);
        }
    }

　　　　递归2：

当n=1时，数组中只有一个数a₁，其全排列只有一种，即为a₁

当n=2时，数组中此时有a₁a₂，其全排列有两种，a₁a₂和a₂a₁，那么此时我们考虑和上面那种情况的关系，我们发现，其实就是在a₁的前后两个位置分别加入了a₂

当n=3时，数组中有a₁a₂a₃，此时全排列有六种，分别为a₁a₂a₃, a₁a₃a₂, a₂a₁a₃, a₂a₃a₁, a₃a₁a₂, 和 a₃a₂a₁。那么根据上面的结论，实际上是在a₁a₂和a₂a₁的基础上在不同的位置上加入a₃而得到的。

　　（3）借用next_permutation的函数

 4. The Kth Permutation Sequence

　　The set [1,2,3,…,n] contains a total of n! unique permutations. Given n and k, return the kth permutation sequence.

string getPermutation(int n, int k) {
        string res;
        string dict = "123456789";
        int factorial = 1;
        for (int i = 1; i < n; ++i) {
            factorial *= i;
        }
        --k;
        while (n--) {
            int pos = k / factorial;
            res += dict[pos];
            k %= factorial;
            factorial /= (n ? n : 1);
            dict.erase(pos, 1);
        }
        return res;
    }