1. Next Permutation
实现C++的std::next_permutation函数，重新排列范围内的元素，返回按照 字典序 排列的下一个值较大的组合。若其已经是最大排列，则返回最小排列，即按升序重新排列元素。不能分配额外的内存空间。
void nextPermutation(vector<int>& nums) { next_permutation(nums.begin(), nums.end()); }
全排列 Permutation 问题已经被古人研究透了，参见 Wikipedia page，Next Permutation 有一个经典的简单有效算法，还能解决含有重复元素的全排列问题。
- 从尾端寻找第一个下标 i，使 nums[i] < nums[i + 1]。若这样的 i 不存在，则这个排列已经是降序排列（或者元素全部相同），那么直接逆序得到升序排列。
- 从尾端寻找第一个下标 j，使 nums[i] < nums[j]。若 i 存在，则 j 一定存在且 i < j，因为 j 起码可以 = i + 1。
- 交换 i 和 j 位置的元素。
- 逆序从 i + 1 到结尾的子数组，即求出下一个序列。
e.g.
nums = [6, 3, 4, 9, 8, 7, 1]
i j
- 找到 i = 2，nums[i] = 4。i 右边的一定是降序排列 [9, 8, 7, 1]。
- 从尾端找第一个大于 nums[i] 的数 7，即 nums[j] = 7。
- 交换 4 和 7，[6, 3, 7, 9, 8, 4, 1]。保证交换后的 [6, 3, 7, ......] 一定大于原来的 [6, 3, 4, ......]，且可以发现 i 右边的 [9, 8, 4, 1] 仍然是降序排列。
- 对 i 右边进行逆序，得到结果 [6, 3, 7, 1, 4, 8, 9]。
C++实现：
1 void nextPermutation(vector<int>& nums) { 2 int j = nums.size() - 1, i = j; 3 while (--i >= 0) { 4 if (nums[i] < nums[i + 1]) 5 break; 6 } 7 if (i != -1) { 8 while (j > i) { 9 if (nums[j] > nums[i]) 10 break; 11 j--; 12 } 13 swap(nums[i], nums[j]); 14 } 15 reverse(nums.begin() + i + 1, nums.end()); 16 return; 17 }
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]
]
我使用递归实现：
1 vector<vector<int>> permute(vector<int>& nums) { 2 vector<vector<int>> result; 3 vector<int> item; 4 add(result, nums, item); 5 return result; 6 } 7 8 void add(vector<vector<int>> &result, vector<int> v, vector<int> item) { 9 if (v.empty()) { 10 result.push_back(item); 11 return; 12 } 13 for (int i = 0; i < v.size(); i++) { 14 item.push_back(v[i]); 15 vector<int> new_v; 16 for (int j = 0; j < v.size(); j++) { 17 if (j == i) continue; 18 new_v.push_back(v[j]); 19 } 20 add(result, new_v, item); 21 item.pop_back(); 22 } 23 }
看到答案一种更好的方法，使用 swap 函数，不需要创建额外的 item 存储大量重复的数据。
如果 permuteRecursive 函数的 num 参数不用引用，则可以去掉第 15 行的 swap，但这样会创建大量的临时 vector，效率低不少。
而且个人觉得这个方法有点难以理解。真是天才！
1 vector<vector<int> > permute(vector<int> &num) { 2 vector<vector<int>> result; 3 permuteRecursive(result, num, 0); 4 return result; 5 } 6 7 void permuteRecursive(vector<vector<int>> &result, vector<int> &num, int begin) { 8 if (begin == num.size()) { 9 result.push_back(num); 10 return; 11 } 12 for (int i = begin; i < num.size(); i++) { 13 swap(num[begin], num[i]); 14 permuteRecursive(result, num, begin + 1); 15 swap(num[begin], num[i]); 16 } 17 }
3. Permutations II
给出一组可能含有重复数字的数组的全排列。
e.g. [1,1,2] 有全排列：
[
[1,1,2],
[1,2,1],
[2,1,1]
]
我使用 (1) Next Permutation 的思路，从升序开始逐个计算下一个全排列。
1 vector<vector<int>> permuteUnique(vector<int>& nums) { 2 vector<vector<int>> result; 3 sort(nums.begin(), nums.end()); 4 do { 5 result.push_back(nums); 6 } while (nextPermutation(nums)); 7 return result; 8 } 9 10 bool nextPermutation(vector<int>& nums) { 11 int i = nums.size() - 1; 12 while (--i >= 0 && nums[i] >= nums[i + 1]); 13 if (i != -1) { 14 int j = nums.size(); 15 while (--j > i && nums[j] <= nums[i]); 16 swap(nums[i], nums[j]); 17 reverse(nums.begin() + i + 1, nums.end()); 18 return true; 19 } 20 return false; 21 }
别人写了一种类似 (2) 中递归的方法，也比较难以理解。这种情况下不能用引用，以及在递归语句后把交换元素再换回来。
1 vector<vector<int> > permuteUnique(vector<int> &num) { 2 sort(num.begin(), num.end()); 3 vector<vector<int>> result; 4 permuteRecursive(result, num, 0); 5 return result; 6 } 7 8 void permuteRecursive(vector<vector<int>> &result, vector<int> num, int begin) { 9 if (begin == num.size()) { 10 result.push_back(num); 11 return; 12 } 13 for (int i = begin; i < num.size(); i++) { 14 if (i > begin && num[i] == num[begin]) continue; 15 swap(num[begin], num[i]); 16 permuteRecursive(result, num, begin + 1); 17 } 18 }