Recurssion issue in generating permutation in c++ - c++

Question

i have two n in c++ and i want to generate permutation of the numbers in those vectors in such a way for each permutation of the first vector i have all the permutations of all the other vectors.
Say i have two vectors with number 2 9 and the other vector will be 5 6. then my result should be...
2 9 5 6
2 9 6 5
9 2 5 6
9 2 6 5
means that the total number of permutations i have got will be
total perms = (# of permutations of the 1st vector times number of permutations of the second vector times number of permutations of the third vector and so on).
I have written the below code and i am struck in to recursion stack... It is actually printing 6 times for the case of 2 vectors each have the size of 2 each.
mySwap(int *x, int *y){
int temp;
temp = *x;
*x = *y;
*y = temp;
}
swaps the two int elements
void myPerm(vector<vector<int>> myItems, int start, int end,int vectorIndex){
int j;
if(start == end){
for(int k = vectorIndex +1; k < items.size(); ++k){
myPerm(myItems, 0, myItems[k].size()-1,k);
}
for(int z = 0; z < myItems.size(); ++z){
for(int l = 0; l < myItems[z].size(); ++z){
std::cout << myItems[z][l];
}
}
}
else{
for(int j = start; j <= end; j++){
mySwap(&myItems[vectorIndex][start],&myItems[vectorIndex][j]);
myPerm(myItems,start + 1, end,vectorIndex);
mySwap(&myItems[vectorIndex][start],&myItems[vectorIndex][j]);
}
}
}
above code that generates permutations recursively...
int main(){
vector<vector<int>> myItems;
int k = 0;
for(int i =0; i < 2; ++i){
myItems.push_back(vector<int>);
}
for(int j =0; j < 2; ++j){
myItems[i].push_back(k++);
}
myPerm(items,0,items[0].size()-1,0);
return;
}
my main function.
Please give me some hint or solve this this for the generic case as the above code prints the permutations for the six which originally should be 4 times.
Thanks

Answer 1

Considering this is not a homework you can simply use stl algorithm next_permutation instead of what you have.
This is the code for your sample input.
int main()
{
std::vector<int> v1 , v2 , v3;
v1.push_back( 2 );
v1.push_back( 9 );
v2.push_back( 5 );
v2.push_back( 6 );
std::sort( v1.begin() , v1.end() );
std::sort( v2.begin() , v2.end() );
do
{
v3 = v2;
do
{
std::for_each( v1.begin() , v1.end() , [](int x) { std::cout << x << " ";} );
std::for_each( v3.begin() , v3.end() , [](int x) { std::cout << x << " ";} );
std::cout << std::endl;
}
while ( std::next_permutation(v3.begin() , v3.end() ) );
}
while ( std::next_permutation(v1.begin() , v1.end() ) );
return 0;
}
This does it for two vectors... I am sure you can generalize it further.

Answer 2

Thanks for all the ideas specially for the STL function next_permutation. I don't know it earlier.
I was able to write the code i want it correctly...
Here is my code
void perm(std::vector<std::vector <int>> &items, int level){
if(level == 0){
for (int i = 0; i < items.size(); i++)
for (int j = 0; j < items[i].size(); j++)
std::cout << items[i][j];
std::cout<<std::endl;
while(next_permutation(items[level].begin(), items[level].end())){
for (int i = 0; i < items.size(); i++)
for (int j = 0; j < items[i].size(); j++)
std::cout << items[i][j];
std::cout<<std::endl;
}
}
else{
if(level > 0)
perm(items,level-1);
while(next_permutation(items[level].begin(), items[level].end())){
if(level > 0)
perm(items,level-1);
}
}
}

Answer 3

For this problem recursion could be omitted entirely by using next_permutation. Here's some untested code that is arguably more elegant:
void myPerm(std::vector<std::vector<int>>& myItems)
{
for (int i = 0; i < myItems.size(); i++)
std::sort(myItems[i].begin(), myItems[i].end());
int level;
do
{
printAll(myItems);
level = myItems.size() - 1;
while (!next_permutation(myItems[level].begin(), myItems[level].end()))
level--;
}
while (level >= 0);
}
Nice thing about next_permutation is that it returns false as it "wraps around" given set, and so the set is sorted and ready for the next round of permutations.