力扣31. 下一个排列

一、用回溯算法

    先找出所有全排列，再排序，找出当前排列的下一个排列。然而该法不满足题目要求：必须 原地 修改，只允许使用额外常数空间，且时间复杂度太高。

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        // 使用回溯算法，找出全排列
        auto all = permute(nums);
        // 对全排列结果排序
        sort(all.begin(), all.end());
        // 找出下一个排列
        for(int i=0; i<all.size(); ++i)
        {
            if(i!=(all.size()-1) && all[i] == nums && all[i+1] != nums)
            {
                nums = all[i+1];
                return;
            } 
            if(all[i] == nums && i==(all.size()-1))
            {
                nums = all[0];
                return;
            }
        }
    }

// 回溯算法找出全排列
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int> &nums, vector<bool> &used)
    {
        if(path.size() == nums.size())
        {
            res.push_back(path);
            return;
        }
        for(int i=0; i<nums.size(); ++i){
            if(used[i]) continue;
            used[i] = true;
            path.emplace_back(nums[i]);
            backtracking(nums, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }
};

二、两遍扫描（C++ 的标准库函数 next_permutation 实现方法）

算法过程
标准的“下一个排列”算法可以描述为：

        1.从后向前查找第一个相邻升序的元素对 (i,j)，满足 A[i] < A[j]。（由于i,j已经是最后一个相邻的升序元素对了，则[j,end)必然满足 相邻元素非升序排列）此时 [j,end) 必然是降序
        2.在 [j,end) 从后向前查找第一个满足 A[i] < A[k] 的 k。
        3.将 A[i] 与 A[k] 交换
        4.可以断定这时 [j,end) 必然是降序，逆置 [j,end)，使其升序
        5.如果在步骤 1 找不到符合的相邻元素对，说明当前 [begin,end) 为一个降序顺序，则直接跳到步骤 4
        该方法支持数据重复，且在 C++ STL 中被采用。

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int i = nums.size() - 2;
        while (i >= 0 && nums[i] >= nums[i + 1]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.size() - 1;
            while (j >= 0 && nums[i] >= nums[j]) {
                j--;
            }
            swap(nums[i], nums[j]);
        }
        reverse(nums.begin() + i + 1, nums.end());
    }
};