How can I generate the following tree of permutations in C++? - c++

Question

Suppose we have the string ABCD
I would like to create the following tree:
ABCD <------ level 1
ABC ABD ACD BCD <------ level 2
AB AC AD BC BD CD <------ level 3
A B C D <------ level 4
And save it inside a vector in the following order:
ABCD->ABC->ABD->ACD->BCD->AB->AC->AD->BC->BD->CD->A->B->C->D
So from the starting point, I want to generate the nodes of the next level, store them inside the vector, then generate the nodes of the next level and do the same thing for all the remaining levels
I have created the following program to generate level 2 from level 1.
void test(int dimensions, vector<string> & nodes, const char* currentNode){
int i,j;
for(i=dimensions-1;i>=0;i--){
char *temp = new char[dimensions];
int counter = 0;
for(j=0;j<dimensions;j++){
if(j!=i){
temp[counter] = currentNode[j];
counter++;
}
}
temp[counter] = '\0';
nodes.push_back(temp);
}
}
which is called from main:
vector<string> nodes;
int dimension = 4;
nodes.push_back("ABCD");
test(dimension, nodes, "ABCD");
This gives me the following:
As you can see the nodes of the level 2 are added successfully, however if I try to apply recursion here, for example for node "ABC"
I would get as a result:
AB -> AC -> BC
These will be saved successfully, however if the recursion keeps going, for example for node AB now it will find A -> B
so the the resulting order of the nodes saved in the vector won't be how I described in the beginning.
Instead of
ABCD->ABC->ABD->ACD->BCD->AB->AC->AD->BC->BD->CD->...
it will be
ABCD->ABC->ABD->ACD->BCD->AB->AC->A->B->...
Finally, I would like the computation of this tree to be generalized for any number of dimensions. For example the initial node could be ABCD or ABCDEFGHIJKLM.
For some reason I believe this is very difficult to do, however I'm not exactly certain about it. Note that I don't want to use any external libraries for computing the permutations, I need to understand 100% the code in order to proceed with the algorithm that I want to implement.
Thank you in advance

Answer 1

As stated in the comments, I don't see how this is remotely related to permutations, but here's the code for what I think you're trying to achieve:
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef std::vector<std::string> Layer;
Layer getNextLayer(const Layer &);
int main()
{
std::vector<Layer> layers;
layers.push_back(Layer());
layers[0].push_back("ABCDE");
while ( layers.back().back().size() > 1 )
{
layers.push_back(getNextLayer(layers.back()));
for ( size_t i = 0; i < layers.back().size(); ++i )
{
std::cout << layers.back()[i] << " ";
}
std::cout << "\n";
}
}
Layer getNextLayer(const Layer &layer)
{
Layer result;
for ( size_t i = 0; i < layer.size(); ++i )
{
const std::string item = layer[i];
for ( size_t j = 0; j < item.size(); ++j )
{
std::string new_item = item;
new_item.erase(new_item.begin() + j); // erase j^th charachter from item
result.push_back(new_item);
}
}
std::sort(result.begin(), result.end());
result.erase(std::unique(result.begin(), result.end()), result.end()); // erase duplicates
return result;
}
This creates each layer based on the last one. To store it all in one vector, you just have to merge all these layers.