LeetCode(46) Permutations

题目如下：

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].

分析如下：

两种思路。第一种，逐步插入生成。第二种，通过交换生成。以[1,2,3]为例来进行说明。

第一种：
    第一步，生成[1]，
    第二步，把2，插入上一步的[1]的所有可能位置中，得到[2,1],[1,2]，
    第三步，把3，插入上一步的结果中。对于[2,1]，3能插入的所有可能位置是3个，得到[3,2,1], [2,3,1],[2,1,3]。对于[1,2]，3能插入的所有可能位置是3个，得到[3,1,2], [1,3,2],      [1,2,3]。
    如果输入数组有N个，就将上面的迭代进行N次。
    上面的代码可以用递归或者迭代来实现。

第二种：

   交换的思路。主要参考了这篇文章 和这篇文章。如下图所示。适合递归来实现。

    

我的代码：

//1: 思路一的迭代版
class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        vector<vector<int> > empty_vec_vec;
        if(num.size()==0) return empty_vec_vec;
        vector<int> inner_result(1, num[0]);
        vector<vector<int> > outer_result(1, inner_result);
        vector<vector<int> > new_outer_result;
        for (int i = 1; i < num.size(); ++i ) {
            for (int j = 0; j < outer_result.size(); ++j) {
                int inner_size = outer_result[j].size();
                for (int k = 0; k <= inner_size; ++k) {
                    inner_result = outer_result[j];
                    inner_result.insert(inner_result.begin() + k, num[i]); 
                    //node insert(argv1, argv2), argv1 is the iterator position.
                    new_outer_result.push_back(inner_result);
                }
            }
            outer_result = new_outer_result;
            new_outer_result.clear();
        }
        return outer_result;
    }
};

//2: 思路一的递归版
class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        if (num.size() == 1){
            vector<int> inner_result(1,num[0]);
            vector<vector<int> > outer_result(1,inner_result);
            return outer_result;
        } else {
            vector<int> sub_num(num.begin() + 1, num.end());
            vector<vector<int> > outer_result = permute(sub_num);
            vector<vector<int> > new_outer;
            vector<int> new_inner;
            for (int i = 0; i < outer_result.size(); ++i) {
                for (int j = 0; j <= outer_result[i].size(); ++j) {
                    new_inner = outer_result[i];
                    new_inner.insert(new_inner.begin() + j, num[0]);
                    new_outer.push_back(new_inner);
                }
            }
            return new_outer;
        }
    }
};

//:3 思路二的递归版
class Solution {
private:
    void swap(vector<int> &num, int i, int j) {
        int temp = num[i];
        num[i] = num[j];
        num[j] = temp;
    }
    void dfs(vector<int> & num, int k, int n, vector<vector<int> >  & result) {
        if (k == n){
            result.push_back(num);
        }else {
            for (int i = k; i <= n; ++i) {
                swap(num, k, i);
                dfs(num, k+1, n, result);
                swap(num, k, i);//每次回到基准点如{1,2,3}，然后进行for循环的下一步。
            }
        }
    }
    
public:
    vector<vector<int> > permute(vector<int> &num) {
        vector<vector<int> > result;
        dfs(num, 0, num.size() -1 , result);
        return result;
    }
};

参考资料：

1 yu's coding garden

2 geeks for geeks