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]
.
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]
.
不用修改,就两个问题都适用的算法,调用STL就行的。运行速度还是很快的。
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
vector<vector<int> > permu;
sort(num.begin(), num.end());
permu.push_back(num);
while (next_permutation(num.begin(), num.end()))
{
permu.push_back(num);
}
return permu;
}
};
但是感觉做这些算法题,直接调用STL是不是有点感觉是作弊的嫌疑,呵呵O(∩_∩)O~
下面看看不使用STL如何做。
Permutations:
回溯法:
代码出自这个blog: http://blog.csdn.net/tuantuanls/article/details/8717262
只有手动走几遍吧,就能理解了。
这个算法是最简单的了
vector<vector<int> > ret;
int N;
void perm(vector<int> &num, int i){
if( i == N){
ret.push_back(num);
}
for(int j = i; j < N; j++){
swap(num[i], num[j]);
perm(num, i + 1);
swap(num[j], num[i]);
}
}
vector<vector<int> > permute3(vector<int> &num) {
N = num.size();
ret.clear();
perm(num, 0);
return ret;
}
下面我用先序遍历树的思想写的代码,画个树理解就好了:
如第一次遍历:访问abc节点,取出a放入结果中,从abd节点到访问bc节点,访问节点c,把b放入结果中,最后访问c,把c放入结果中,每一条路径就是一个解,这里总共有6条路径,刚好是六个解。遍历完,答案就出来了。
和前面的回溯思想有一点差别,但是最基本思想差不多是一致的,要把这些思想融合起来,做到融会贯通!
//5===============
vector<vector<int> > permute5(vector<int> &num) {
vector<int> mediRes;
vector<vector<int> > res;
permu(num, mediRes, res);
return res;
}
void permu(vector<int> &num, vector<int> &mediRes, vector<vector<int> > &ret)
{
int N = num.size();
if (N == 1)
{
mediRes.push_back(num[0]);
ret.push_back(mediRes);
mediRes.pop_back();
return;
}
for (int i = 0; i < N; i++)
{
mediRes.push_back(num[i]);
vector<int> cur = num;
cur.erase(cur.begin()+i);
permu(cur, mediRes, ret);
mediRes.pop_back();//注意:别忘记了这里需要弹出,不要等到循环结束
}
}
Permutations II
这个问题主要就增加防止重复的判断就可以了。
两种方法:
1 使用sort排序,然后排除相邻的重复数字。注意没排序的不可以这么判断
2 利用一个新的容器,装已经处理的数字,不重复处理数字,利用map和set等都可以。
方法一程序:
vector<vector<int> > permuteUnique2(vector<int> &num) {
mediRes.clear();
res.clear();
sort(num.begin(), num.end());
permuII2(num);
return res;
}
void permuII2(vector<int> &num)
{
int m = num.size();
if (m == 1)
{
mediRes.push_back(num[0]);
res.push_back(mediRes);
mediRes.pop_back();
return;
}
//如果已经排序了的就可以值处理相邻的重复了
for (int i = 0; i < m; i++)
{
while (i < m-1 && num[i] == num[i+1]) i++;
mediRes.push_back(num[i]);
vector<int> cur = num;
cur.erase(cur.begin()+i);
permuII2(cur);
mediRes.pop_back();//注意:别忘记了这里需要弹出,不要等到循环结束
}
}
vector<vector<int> > res;
vector<int> mediRes;
vector<vector<int> > permuteUnique(vector<int> &num) {
mediRes.clear();
res.clear();
permuII(num);
return res;
}
void permuII(vector<int> &num)
{
int m = num.size();
if (m == 1)
{
mediRes.push_back(num[0]);
res.push_back(mediRes);
mediRes.pop_back();
return;
}
//注意:不能光判断相邻的是否重复,不相邻的重复也会出现重复结果的。
//脑子要放大
unordered_set<int> used;
for (int i = 0; i < m; i++)
{
if (used.find(num[i]) == used.end())
{
mediRes.push_back(num[i]);
vector<int> cur = num;
cur.erase(cur.begin()+i);
permuII(cur);
mediRes.pop_back();//注意:别忘记了这里需要弹出,不要等到循环结束
used.insert(num[i]);
}
}
}
2013.12.12Update更新一个特别的方法:
参考博客:
http://blog.csdn.net/tuantuanls/article/details/8717262
思路四
我觉得思路4是一个很常规的思路,很多把recursive的code改成iterative的code都会用到这样的方法,其实呢,它的本质就是把N个for改成while的方法。介个方法在编程之美里面的“电话号码”那一节提到过,不明白的童鞋可以去看一看,我觉得第一次想写粗来还是很难的,不过多写几个,就会很熟练啦
对应介个题目的思路捏就是。。。举个例子来说吧
如果我想求1,2,3,4的全排列
偶的思路就是建一个特殊的数,它的进位方法是 3, 2, 1, 0
所以,这个数的++过程就是
0000 -> 0010 -> 0100 -> 0110 ->0200 -> 0210 ->
1000 -> 1010 -> 1100 -> 1110 ->1200 -> 1210 ->
2000 -> 2010 -> 2100 -> 2110 ->2200 -> 2210 ->
3000 -> 3010 -> 3100 -> 3110 ->3200 -> 3210
哇哈哈哈,刚好是24个!
然后捏? b0 b1 b2 b3就代表在当前剩下的数字中选择第bi个
哇!好复杂。。。
比如0210
0: 在1234中选择第0个,就是1
2: 在234中选择滴2个,就是4
1: 在23中选择第1个,就是3
0: 在2中选择第0个,就是2
所以0210对应点就素 1432
class Solution {
public:
int factorial(int n)
{
int res = 1;
for (int i = 2; i <= n; i++)
{
res *= i;
}
return res;
}
void addOne(vector<int> &table, const vector<int> &bound)
{
for (int i = table.size()-2; i >= 0; i--)
{
//可以是==的所以是>不是>=
if (++table[i] > bound[i]) table[i] = 0;
else break;
}
}
vector<vector<int> > permute(vector<int> &num)
{
int n = num.size();
vector<vector<int> > res;
if (n < 1) return res;
vector<int> medRes(n);
vector<int> temp(n);
vector<int> table(n);
vector<int> bound(n);
for (int i = 0; i < n; i++)
{
bound[i] = n-1-i;
}
int fac = factorial(n);
for (int i = 0; i < fac; i++)
{
temp = num;
for (int j = 0; j < n; j++)
{
medRes[j] = temp[table[j]];
temp.erase(temp.begin()+table[j]);
}
res.push_back(medRes);
addOne(table, bound);
}
return res;
}
};