标签：
转：http://www.cnblogs.com/felixfang/p/3705754.html
Permutation，排列问题。这篇博文以几道LeetCode的题目和引用剑指offer上的一道例题入手，小谈一下这种类型题目的解法。
最典型的permutation题目是这样的：
Given a collection of numbers, return all possible permutations.
For example,[1,2,3] have the following permutations:[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].
class Solution {
public:
vector<vector<int> > permute(vector<int> &num) {
}
};
我第一次接触这类问题是在剑指offer里，见笔记 面试题 28(*)，字符串的排列(排列问题的典型解法：采用递归，每次交换首元素和剩下元素中某一个的位置) 。
书中对这种问题采用的方法是“交换元素”，这种方法的好处是不需要再新开一个数组存临时解，从而节省一部分辅助空间。
交换法的思路是for(i = start to end)，循环中: swap (第start个和第i个)，递归调用(start+1)，swap back
根据这个思路，可以轻易写出这道题的代码：
class Solution {
public:
vector<vector<int> > permute(vector<int> &num) {
if(num.size() == 0) return res;
permuteCore(num, 0);
return res;
}
private:
vector<vector<int> > res;
void permuteCore(vector<int> &num, int start){
if(start == num.size()){
vector<int> v;
for(vector<int>::iterator i = num.begin(); i < num.end(); ++i){
v.push_back(*i);
}
res.push_back(v);
}
for(int i = start; i < num.size(); ++i){
swap(num, start, i);
permuteCore(num, start+1);
swap(num, start, i);
}
}
void swap(vector<int> &num, int left, int right){
int tmp = num[left];
num[left] = num[right];
num[right] = tmp;
}
};
permutation II 是在上一题的基础上，增加了“数组元素可能重复”的条件。
这样，如果用交换法来解，需要定义一个set来存储已经交换过的元素值。
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
if(num.size() <= 0) return res;
permCore(num, 0);
return res;
}
private:
vector<vector<int> > res;
void permCore(vector<int> &num, int st){
if(st == num.size()) res.push_back(num);
else{
set<int> swp;
for(int i = st; i < num.size(); ++i){
if(swp.find(num[i]) != swp.end()) continue;
swp.insert(num[i]);
swap(num, st, i);
permCore(num, st+1);
swap(num, st, i);
}
}
}
void swap(vector<int> &num, int left, int right){
int tmp = num[left];
num[left] = num[right];
num[right] = tmp;
}
};
题外话：交换法只是解法的一种，其实我们还可以借鉴Next permuation的思路(见这个系列的第二篇)来解这一道题，从而省去了使用递归。
使用Next permutation的思路来解 Permutation II
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
if(num.size() <= 0) return res;
sort(num.begin(), num.end());
res.push_back(num);
int i = 0, j = 0;
while(1){
//Calculate next permutation
for(i = num.size()-2; i >= 0 && num[i] >= num[i+1]; --i);
if(i < 0) break;
for(j = num.size()-1; j > i && num[j] <= num[i]; --j);
swap(num, i, j);
j = num.size()-1;
++i;
while(i < j)
swap(num, i++, j--);
//push next permutation
res.push_back(num);
}
return res;
}
private:
vector<vector<int> > res;
void swap(vector<int> &num, int left, int right){
int tmp = num[left];
num[left] = num[right];
num[right] = tmp;
}
};
Permutation类问题一个典型的应用就是N皇后问题，以LeetCode上的n-queens题和 n-queens II 为例：
The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.
Given an integer n, return all distinct solutions to the n-queens puzzle.
Each solution contains a distinct board configuration of the n-queens‘ placement, where ‘Q‘ and ‘.‘ both indicate a queen and an empty space respectively.
For example,
There exist two distinct solutions to the 4-queens puzzle:
[ [".Q..", // Solution 1 "...Q", "Q...", "..Q."], ["..Q.", // Solution 2 "Q...", "...Q", ".Q.."] ]
class Solution {
public:
vector<vector<string> > solveNQueens(int n) {
}
};
上面是题 n-queens 的内容，题 n-queens II 其实反而更容易，它要求不变，只是不需要返回所有解，只要返回解的个数。
有了上面的思路，如果用A[i] = j 表示第i 行的皇后放在第j列上，N-queen也是一个全排列问题，只是排列时需要加上一个额外判断，就是两个皇后是否在一条斜线上。
真正实现的时候我犯了一个错误。
如上所说，交换法的思路是for(i = start to end)，循环中: switch(第start个和第i个)，递归调用(start+1)，switch back
我错误的认为N皇后不需要switch back，其实 switch back是必须要做的步骤，因为这种解法的本质是还是深搜，子递归会层层调用下去，不及时swtich back的话，当前层的下一次递归调用会把重复的值switch过来，从而出现重复，结果是漏掉了一些正确的排列方法。因此，使用交换法解全排列问题时，不可打乱递归调用时的排列。
题N-Queens被AC的代码：
class Solution {
public:
vector<vector<string> > solveNQueens(int n) {
if(n <= 0) return res;
int* A = new int[n];
for(int i = 0; i < n; ++i) A[i] = i;
nqueensCore(A, 0, n);
return res;
}
private:
vector<vector<string> > res;
void nqueensCore(int A[], int start, int n){
if((start+1) == n && judgeAttackDiag(A, start))
output(A, n);
else{
for(int i = start; i < n; ++i){
swtich(A, start, i);
if(judgeAttackDiag(A, start))
nqueensCore(A, start+1, n);
swtich(A, start, i);
}
}
}
void swtich(int A[], int left, int right){
int temp = A[left];
A[left] = A[right];
A[right] = temp;
}
bool judgeAttackDiag(int A[], int newPlace){ //everytime a new place is configured out, judge if it can be attacked by the existing queens
if(newPlace <= 0) return true;
bool canAttack = false;
for(int i = 0; i < newPlace; ++i){
if((newPlace - i) == (A[newPlace] - A[i]) || (i - newPlace) == (A[newPlace] - A[i])) canAttack = true;
}
return !canAttack;
}
void output(int A[], int n){
vector<string> v;
for(int i = 0; i < n; ++i){
string row(n,‘.‘);
v.push_back(row);
}
for(int j = 0; j < n; ++j){
v[A[j]][j] = ‘Q‘;
}
res.push_back(v);
}
};
Follow up for N-Queens problem.
Now, instead outputting board configurations, return the total number of distinct solutions.
class Solution {
public:
int totalNQueens(int n) {
}
};
基本思路依然是使用全排列，这次代码可以写得简洁一些。
class Solution {
public:
int totalNQueens(int n) {
if(n <= 1) return n;
res = 0;
queens = new int[n];
for(int i = 0; i < n; queens[i] = i, ++i);
nQueensCore(queens, n, 0);
return res;
}
private:
int res;
int* queens;
void nQueensCore(int* queens, int n, int st){
if(st == n) ++res;
int tmp, i, j;
for(i = st; i < n; ++i){
tmp = queens[st];
queens[st] = queens[i];
queens[i] = tmp;
for(j = 0; j < st; ++j){
if(abs(queens[st] - queens[j]) == abs(st - j)) break;
}
if(j == st) nQueensCore(queens, n, st+1);
tmp = queens[st];
queens[st] = queens[i];
queens[i] = tmp;
}
}
};
我第一次提交时依然犯了忘掉switch back的错误，第一次提交的代码中，写的是“if(abs(queens[st] - queens[j]) == abs(st - j)) return;"
这样就导致了switch back部分代码(高亮部分)不会被执行，从而打乱了整个顺序。
数独和N 皇后一样，都是需要不停地计算当前位置上所摆放的数字是否满足条件，不满足就回溯，摆放另一个数字，基于这个新数字再计算。
选择新数字的过程，就是全排列的过程。
以LeetCode上的例题为例:
Write a program to solve a Sudoku puzzle by filling the empty cells.
Empty cells are indicated by the character ‘.‘.
You may assume that there will be only one unique solution.
A sudoku puzzle...
...and its solution numbers marked in red.
void solveSudoku(vector<vector<char> > &board) {}
关于数独的规则，请参见这里：Sudoku Puzzles - The Rules. 必须保证每行，每列，和9个3X3方块中1-9各自都只出现一次。
我们依然可以用交换法来解，思路依然是：
for(i = start to end)，循环中: swap (第start个和第i个)；如果当前排列正确，递归调用(start+1)；swap back
这里需要额外考虑的是：数独阵列中有一些固有数字，这些数字是一开始就不能动。因此，我用flag[][]来标记一个位置上的数字是否可替换。flag[i][j] == true表示Board[i][j]上的数字可替换，false表示不可替换。因此思路稍加变更，成了：
Func(start){
a. 如果 flag上start对应的位置 == false，说明当前位不能改动，因此只需判断当前排列是否正确，正确则递归调用(start+1)
b. flag上start对应的位置 = false
c. for(i = start 到当前行末尾)，循环中: swap (第start个和第i个)；如果当前排列正确，递归调用(start+1)；swap back
d. flag上start对应的位置 = true
}
代码：
class Solution {
public:
void solveSudoku(vector<vector<char> > &board) {
flag = new bool*[10]; //flag[i][j] == false means value on board[i][j] is decided or originally given.
digits = new bool[10]; //digits is used to check whether one digit (1-9) is duplicated in sub 3*3 square
int i = 0, j = 0;
for(; i < 9; ++i){
flag[i] = new bool[9];
for(j = 0; j < 9; ++j){
if(board[i][j] == ‘.‘) flag[i][j] = true;
else flag[i][j] = false;
}
}
initialBoard(board, 9); //初始化Board，先把所有的空缺填满，填的时候先保证每一行没有重复数字。
solveSudokuCore(board, 0);
}
private:
bool **flag;
bool *digits;
void initialBoard(vector<vector<char> > &board, int N){
int i, j, k;
bool *op = new bool[N+1];
for(i = 0; i < N; ++i){
for(j = 0; j <= N; ++j) op[j] = false;
for(j = 0; j < N; ++j){
if(board[i][j] != ‘.‘) op[board[i][j] - ‘0‘] = true;
}
for(j = 0, k = 1; j < N; ++j){
if(board[i][j] == ‘.‘){
while(op[k++]);
board[i][j] = ((k-1) + ‘0‘);
}
}
}
delete op;
}
bool check(vector<vector<char> > &board, int index){
int col = index%9, row = index/9;
int i = 0;
for(i = 0; i < 9; ++i){
if(i != row && !flag[i][col] && board[i][col] == board[row][col])
return false;
}
if((col+1)%3 == 0 && (row+1)%3 == 0){
for(i = 0; i < 10; ++i) digits[i] = false;
for(int j = (row/3)*3; j < (row/3+1)*3; ++j){
for(int k = (col/3)*3; k < (col/3+1)*3; ++k){
if(digits[board[j][k] - ‘0‘]) return false;
digits[board[j][k] - ‘0‘] = true;
}
}
}
return true;
}
bool solveSudokuCore(vector<vector<char> > &board, int index){
if(index == 81) return true;
if(!flag[index/9][index%9]){ //如果当前位置是不可更改的，那么只要check一下是否正确就可以了
if(check(board, index) && solveSudokuCore(board, index+1))
return true;
}else{ //如果当前位置是可更改的，那么需要通过交换不停替换当前位，看哪一个数字放在当前位上是正确的。
flag[index/9][index%9] = false;
for(int i = index; i < (index/9+1)*9; ++i){
if(flag[i/9][i%9] || i == index){
int tmp = board[i/9][i%9];
board[i/9][i%9] = board[index/9][index%9];
board[index/9][index%9] = tmp;
if(check(board, index) && solveSudokuCore(board, index+1))
return true; //如果当前位上放这个数字正确，那么继续计算下一位上该放哪个数字。
tmp = board[i/9][i%9];
board[i/9][i%9] = board[index/9][index%9];
board[index/9][index%9] = tmp;
}
}
flag[index/9][index%9] = true;
}
return false;
}
};
如果要生成全排列的序列中包含重复元素，该如何做呢？以LeetCode上的题 Permutations II 为例：
Given a collection of numbers that might contain duplicates, return all possible unique permutations.
For example,[1,1,2] have the following unique permutations:[1,1,2], [1,2,1], and [2,1,1].
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
}
};
思路：
比如[1, 1, 2, 2]，我们交换过一次 位置1上的"1"和 位置3上的"2"，就不再需要交换 位置1上的"1" 和 位置4上的"2"了。
因此，在传统的交换法的基础上，需要加一个过滤：比如当前我们 需要挨个将位置 2-4的元素和位置1上的"1" 交换，此时，如果2-4上的元素有重复值，我们只需要用第一次出现的那个值和位置1做交换即可。
我开始的思路是：先将位置2-4的元素sort一下，然后定义pre存放上次交换的元素的值，如果当前值和pre不同，则交换当前值和位置1上的值。
按照这种方式实现的代码是：
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
if(num.size() == 0) return res;
permuteCore(num, 0);
return res;
}
private:
vector<vector<int> > res;
void permuteCore(vector<int> &num, int start){
if(start == num.size()){
vector<int> v;
for(vector<int>::iterator i = num.begin(); i < num.end(); ++i){
v.push_back(*i);
}
res.push_back(v);
}
sort(num.begin()+start, num.end());
int pre;
for(int i = start; i < num.size(); ++i){
if(i == start || pre != num[i]){
swap(num, start, i);
permuteCore(num, start+1);
swap(num, start, i);
pre = num[i];
}
}
}
void swap(vector<int> &num, int left, int right){
int tmp = num[left];
num[left] = num[right];
num[right] = tmp;
}
};
然而判定结果是 Output Limit Exceeded，分析了一下原因，在于Sort破坏了当前子排列，导致出现了重复解。正如我上一节中所说，使用交换法解全排列问题时，不可打乱递归调用时的排列，不然可能导致重复解。
不用sort来做判断的话，那就使用set 来去重吧。将上面代码的高亮部分换成下面代码的高亮部分，这次就AC了。
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
if(num.size() == 0) return res;
permuteCore(num, 0);
return res;
}
private:
vector<vector<int> > res;
void permuteCore(vector<int> &num, int start){
if(start == num.size()){
vector<int> v;
for(vector<int>::iterator i = num.begin(); i < num.end(); ++i){
v.push_back(*i);
}
res.push_back(v);
}
set<int> used;
for(int i = start; i < num.size(); ++i){
if(used.find(num[i]) == used.end()){
swap(num, start, i);
permuteCore(num, start+1);
swap(num, start, i);
used.insert(num[i]);
}
}
}
void swap(vector<int> &num, int left, int right){
int tmp = num[left];
num[left] = num[right];
num[right] = tmp;
}
};
但这种解法的缺点在于比较费空间，set 需要定义在局部变量区，这样才能保证递归函数不混用set。
对于全排列问题，交换法是一种比较基本的方法，其优点就在于不需要额外的空间。
使用时需要注意
a. 不要打乱子问题的序列顺序。
b. 记得换回来，回溯才能正确进行，也就是说，负责switch back部分的代码必须被执行到。
[LeetCode] “全排列”问题系列(一) - 用交换元素法生成全排列及其应用，例题: Permutations I 和 II, N-Queens I 和 II，数独问题
标签：
原文地址：http://www.cnblogs.com/qiaozhoulin/p/4771622.html
