“全排列”问题系列(一)[LeetCode] - 用交换元素法生成全排列及其应用，例题: Permutations I 和 II, N-Queens I 和 II，数独问题

转：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 为例：

n-queens

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);
    }
};

N-Queens II

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部分代码(高亮部分)不会被执行，从而打乱了整个顺序。

3. 数独问题

数独和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部分的代码必须被执行到。