LeetCode Permutations （全排列）

题意：

　　给出n个元素，请产生出所有的全排列。

思路：

　　注意到可能会有相同的排列出现，比如 {2，2}。还有可能是乱序列（大部分情况下都是无所谓的）。

　　递归（1）：产生的过多的多余vector。

class Solution {
public:
    void recursion(vector<int> num, int i,  vector<vector<int> > &res) 
    {
        if (i+1==num.size())    res.push_back(num);
        else
        {
            for (int j=i; j<num.size(); j++)
            {
                if(j!=i&&num[i]==num[j])    continue;    
                swap(num[i], num[j]);
                recursion(num, i+1, res);
            }
        }
    }
    vector<vector<int> > permute(vector<int> &num) 
    {
        vector<vector<int> >res;
        recursion(num, 0, res);
        return res;
    }
};

　　 递归（2）：只要保证每次交换后都能换回来，必定能恢复到原来的样子，所以不需要产生过多的多余vector。

class Solution {
    vector<vector<int> > ans;     
public:

    void DFS(vector<int>& num,int pos)
    {
        if(pos+1==num.size())    ans.push_back(num);
        else
        {
            for(int i=pos; i<num.size(); i++)
            {
                swap(num[i],num[pos]);
                DFS(num,pos+1);
            swap(num[i],num[pos]);//换回来
            }
        }
    }

    vector<vector<int> > permute(vector<int> &num)
    {
        if(!num.empty())    DFS(num,0);
        return ans;
    }
};

　　迭代法：类似于BFS，由于不会有重复的数字，所以一个个数来分配。当分配一个数时，只要其前面不会有相同的数，就可以插入到末尾。速度也慢了很多。

class Solution {
    deque<vector<int> > que;    
public:

    bool isok(vector<int>& num,int a)
    {
        for(int i=0; i+1<num.size(); i++)
            if(num[i]==a)    return false;
        return true;
    }


    vector<vector<int> > permute(vector<int> &num)
    {
        que.push_back(vector<int>());
        for(int i=0; i<num.size(); i++)
        {
            int siz=que.size();
            for(int j=0; j<siz; j++)
            {
                vector<int> tmp(que.front());
                que.pop_front();
                tmp.push_back(0);
                for(int k=0; k<num.size(); k++)
                {
                    if(isok(tmp,num[k]))
                    {
                        tmp[i]=num[k];
                        que.push_back(tmp);
                    }
                }
            }
        }
        return vector<vector<int> >(que.begin(),que.end());
    }
};