【LeetCode】Permutation全排列

1. Next Permutation

实现C++的std::next_permutation函数，重新排列范围内的元素，返回按照 字典序 排列的下一个值较大的组合。若其已经是最大排列，则返回最小排列，即按升序重新排列元素。不能分配额外的内存空间。

void nextPermutation(vector<int>& nums) {
    next_permutation(nums.begin(), nums.end());
}

全排列 Permutation 问题已经被古人研究透了，参见 Wikipedia page，Next Permutation 有一个经典的简单有效算法，还能解决含有重复元素的全排列问题。

1. 从尾端寻找第一个下标 i，使 nums[i] < nums[i + 1]。若这样的 i 不存在，则这个排列已经是降序排列（或者元素全部相同），那么直接逆序得到升序排列。
2. 从尾端寻找第一个下标 j，使 nums[i] < nums[j]。若 i 存在，则 j 一定存在且 i < j，因为 j 起码可以 = i + 1。
3. 交换 i 和 j 位置的元素。
4. 逆序从 i + 1 到结尾的子数组，即求出下一个序列。

e.g.

nums = [6, 3, 4, 9, 8, 7, 1]
              i        j

1. 找到 i = 2，nums[i] = 4。i 右边的一定是降序排列 [9, 8, 7, 1]。
2. 从尾端找第一个大于 nums[i] 的数 7，即 nums[j] = 7。
3. 交换 4 和 7，[6, 3, 7, 9, 8, 4, 1]。保证交换后的 [6, 3, 7, ......] 一定大于原来的 [6, 3, 4, ......]，且可以发现 i 右边的 [9, 8, 4, 1] 仍然是降序排列。
4. 对 i 右边进行逆序，得到结果 [6, 3, 7, 1, 4, 8, 9]。

C++实现：

 void nextPermutation(vector<int>& nums) {
     int j = nums.size() - , i = j;
     while (--i >= ) {
         if (nums[i] < nums[i + ])
             break;
     }
     if (i != -) {
         while (j > i) {
             if (nums[j] > nums[i])
                 break;
             j--;
         }
         swap(nums[i], nums[j]);
     }
     reverse(nums.begin() + i + , nums.end());
     return;
 }

2. Permutations

给出一组不含重复数字的数组的全排列。

e.g. [1,2,3] 有全排列：

[
    [1,2,3],
    [1,3,2],
    [2,1,3],
    [2,3,1],
    [3,1,2],
    [3,2,1]
]

我使用递归实现：

 vector<vector<int>> permute(vector<int>& nums) {
     vector<vector<int>> result;
     vector<int> item;
     add(result, nums, item);
     return result;
 }

 void add(vector<vector<int>> &result, vector<int> v, vector<int> item) {
     if (v.empty()) {
         result.push_back(item);
         return;
     }
     for (int i = ; i < v.size(); i++) {
         item.push_back(v[i]);
         vector<int> new_v;
         for (int j = ; j < v.size(); j++) {
             if (j == i) continue;
             new_v.push_back(v[j]);
         }
         add(result, new_v, item);
         item.pop_back();
     }
 }

看到答案一种更好的方法，使用 swap 函数，不需要创建额外的 item 存储大量重复的数据。

如果 permuteRecursive 函数的 num 参数不用引用，则可以去掉第 15 行的 swap，但这样会创建大量的临时 vector，效率低不少。

而且个人觉得这个方法有点难以理解。真是天才！

 vector<vector<int> > permute(vector<int> &num) {
     vector<vector<int>> result;
     permuteRecursive(result, num, );
     return result;
 }

 void permuteRecursive(vector<vector<int>> &result, vector<int> &num, int begin) {
     if (begin == num.size()) {
         result.push_back(num);
         return;
     }
     for (int i = begin; i < num.size(); i++) {
         swap(num[begin], num[i]);
         permuteRecursive(result, num, begin + );
         swap(num[begin], num[i]);
     }
 }

3. Permutations II

给出一组可能含有重复数字的数组的全排列。

e.g. [1,1,2] 有全排列：

[
    [1,1,2],
    [1,2,1],
    [2,1,1]
]

我使用 (1) Next Permutation 的思路，从升序开始逐个计算下一个全排列。

 vector<vector<int>> permuteUnique(vector<int>& nums) {
     vector<vector<int>> result;
     sort(nums.begin(), nums.end());
     do {
         result.push_back(nums);
     } while (nextPermutation(nums));
     return result;
 }

 bool nextPermutation(vector<int>& nums) {
     int i = nums.size() - ;
     while (--i >=  && nums[i] >= nums[i + ]);
     if (i != -) {
         int j = nums.size();
         while (--j > i && nums[j] <= nums[i]);
         swap(nums[i], nums[j]);
         reverse(nums.begin() + i + , nums.end());
         return true;
     }
     return false;
 }

别人写了一种类似 (2) 中递归的方法，也比较难以理解。这种情况下不能用引用，以及在递归语句后把交换元素再换回来。

 vector<vector<int> > permuteUnique(vector<int> &num) {
     sort(num.begin(), num.end());
     vector<vector<int>> result;
     permuteRecursive(result, num, );
     return result;
 }

 void permuteRecursive(vector<vector<int>> &result, vector<int> num, int begin) {
     if (begin == num.size()) {
         result.push_back(num);
         return;
     }
     for (int i = begin; i < num.size(); i++) {
         if (i > begin && num[i] == num[begin])  continue;
         swap(num[begin], num[i]);
         permuteRecursive(result, num, begin + );
     }
 }