//Code:
//Code 1:
vector<vector<int>> permute(vector<int>& nums) {
if(nums.empty()) return {};
std::vector<std::vector<int>> result;
std::function<void(std::vector<int>&, std::vector<std::vector<int>>&, int, int)>
permuteHelper =
[&](std::vector<int>& nums, std::vector<std::vector<int>>& result, int beg, int end)
{
if(beg == end)
{
result.emplace_back(nums);
return;
}
for(int i = beg; i < end; ++i)
{
std::swap(nums[i], nums[end - 1]);
permuteHelper(nums, result, beg, end - 1); // The important is end-1, not beg + 1
std::swap(nums[i], nums[end - 1]);
}
};
permuteHelper(nums, result, 0, nums.size());
return result;
}
std::vector<std::vector<int>> permute(std::vector<int>& nums)
{
if (nums.empty()) return{};
std::function<void(std::vector<std::vector<int>>&, std::vector<int>&, int, int)> permuteHelper =
[&](std::vector<std::vector<int>> &result, std::vector<int> &num, int begin, int end)
{
if (begin > end)
{
result.emplace_back(num);
return;
}
permuteHelper(result, num, begin, end - 1);
for (int i = begin; i <= end - 1; ++i)
{
std::swap(num[i], num[end]);
permuteHelper(result, num, begin, end - 1);
std::swap(num[i], num[end]);
}
};
std::vector<std::vector<int>> result;
permuteHelper(result, nums, 0, nums.size() - 1);
return result;
}
vector<vector<int> > permute(vector<int> &num) {
vector<vector<int> >res;
// res.push_back(num);
int curNum = 0;
permuteHelper(num, 0, num.size(),res, curNum);
return res;
}
void permuteHelper ( int * array , int len , int ind )
{
// TreeNode * root = NULL ;
int check ;
if ( ind == len )
{
check = isStackSortable( array, len) ;
if(check == 1)
{
TreeNode * root = Tree_build(array, len) ;
Tree_printShape(root) ;
// printPermutation ( array , len );
Tree_destroy(root) ;
}
}
int pos ;
for ( pos = ind ; pos < len ; pos ++)
{
swap (& array [ pos ] , & array [ ind ]);
permuteHelper ( array , len , ind + 1);
swap (& array [ pos ] , & array [ ind ]);
}
}
vector<vector<int> > permuteUnique(vector<int> &num) {
vector<vector<int> > res;
vector<int> path;
vector<int> visited(num.size(), 0);
sort(num.begin(), num.end());
permuteHelper(res, num, 0, path, visited);
return res;
}
void permuteHelper(vector<int> &num, int start, int end, vector<vector<int> > &res, int &curNum) {
if (curNum >= end) {
res.push_back(num);
return;
}
for (int j = start; j < end; ++j) {
swap(num[start], num[j]);
++curNum;
permuteHelper(num,start+1,end, res,curNum);
--curNum;
swap(num[start], num[j]);
}
}
vector<vector<int>> SubSetTest::permute( const vector<int>& num )
{
vector<vector<int>> rst;
if (num.size() == 0)
{
return rst;
}
vector<int> list;
permuteHelper(rst, list, num);
return rst;
}
void permuteHelper(vector<int> &nums, int start, vector<vector<int> > &res){
int sz = nums.size();
if(start == sz){
if(sz != 0)
res.push_back(nums);
return;
}
for(int i = start; i < sz; i++){
swap(nums[start], nums[i]);
permuteHelper(nums, start + 1, res);
swap(nums[i], nums[start]);
}
}
void permuteHelper(vector<vector<int> >& res, const vector<int>& num, int idx, vector<int>& path, vector<int>& visited) {
if(idx == num.size()) {
res.push_back(path);
return;
}
for(int i = 0; i < num.size(); ++i) {
if(visited[i] == 1 || (i!=0 && num[i] == num[i-1] && visited[i-1] == 0 )) {
continue;
} else {
visited[i] = 1;
path.push_back(num[i]);
permuteHelper(res, num, idx+1, path, visited);
path.pop_back();
visited[i] = 0;
}
}
}
void SubSetTest::permuteHelper( vector<vector<int>>& rst, vector<int>& list, const vector<int>& num )
{
if (list.size() == num.size())
{
rst.push_back(list);
return;
}
for (int i = 0; i < num.size(); ++i)
{
if (find(list.begin(), list.end(), num[i]) != list.end())
{
continue;
}
list.push_back(num[i]);
permuteHelper(rst, list, num);
list.pop_back();
}
}
vector<vector<int> > permute(vector<int> &nums) {
vector<vector<int> > res;
permuteHelper(nums, 0, res);
return res;
}
void permute ( int * array , int len )
{
permuteHelper ( array , len , 0);
}
