In this tutorial, we’ll present the recursive and iterative algorithms for generating permutations with repetition. Finding all permutations with repetition is a combinatorial problem like generating all -combinations of a set.
2. Permutations With Repetition
Permutations with repetition of a set are ordered tuples whose elements come from and may be repeated. If the tuples’ length is , we call them -tuples. For example, with and , the following are 4-tuples of :
Our task is to generate all the -tuples of a set . If , there are such tuples.
Here, we’ll take to be of the form . We don’t lose generality in doing so because we can map each set of elements to . So, we can map each -tuple of back to the elements of the original set.
To ease notation, we’ll write instead of .
3. Recursive Algorithm for Generating Permutations with Repetition
We can define permutations with repetition by induction over :
- If , then the only permutation is the empty one that we’ll denote as .
- If , then any -tuple can be obtained by prepending a number from to a -tuple.
These rules give us the logic to follow recursively. is the base case, and for each we prepend every to each tuple we got for .
Here’s the pseudocode of the recursive solution:
Let’s see how the function works. Let’s say that and that we want to find all the 3-tuples. The call returns 2-tuples:
To get -tuples, we first prepend 1 to all the 2-tuples and get:
Then, we prepend 2:
Then, after doing the same with 3, 4, and 5, we get all the 3-tuples.
4. Iterative Algorithm for Generating Permutations with Repetition
The recursive algorithm makes the -tuples available once it generates them all. That is, we can’t access any -tuple before generating all of them first. Since there are of them, the recursive algorithm’s space complexity is . If our application is memory-constrained, this isn’t the way to go.
Moreover, we usually want to filter the permutations to keep only some of them. So, at any time of execution, we’ll be processing a single -tuple, which is why there’s no need for storing all the permutations. It would be best if we could do something like this:
- ask for a permutation
- process it and go to the previous step to ask for another -tuple
In that case, we’d need only space, which is a significant reduction compared to the recursive algorithm whose memory complexity grows exponentially with . We can achieve that with an algorithm that receives a permutation as its input and returns the next permutation in the lexicographic order. Let’s name that algorithm . Then, we start with the first permutation, and then, by calling , we iteratively generate and process all the other permutations:
So, should return the next permutation if there is one, and if we ask it for the last -tuple’s successor. But, how do we implement ?
4.1. Generating the Next Permutation
This is the main idea. A permutation and its successor will have a common prefix. For example, with , is the successor of , and their common prefix is . The suffix that is different starts at the rightmost lower than . In this example, that was 4 in . We increment it by one and get .
However, this doesn’t cover all the cases. What if there’s an in the suffix we’re about to change? Let’s consider . The rightmost element lower than is 3. But, if we increment by 1, we get , whereas the actual successor is . So, what’s the correct logic?
The solution is to realize that the operation we should perform on every after is the circular increment. We increase by one all the numbers except , which we change to 1. But, if all the numbers are equal to , then there’s no successor. It’s the last permutation, so we should return to stop the caller’s loop.
Here’s the pseudocode of :
As we see, apart from the auxiliary variables, doesn’t require more than memory to find the input’s successor.
Let’s work out an example. Let’s say that and .
First, we determine where the suffix to change starts. The rightmost element lower than 7 is 2, so the suffix to change is . Next, we increment 2 by 1 to get 3 and replace all sevens with ones. The permutation we get is , which is the correct result.
It’s interesting to note that if we used as instead of , would amount to incrementing by 1 modulo .
In this article, we presented two ways to generate all the permutations with repetition of the set . The recursive algorithm returns all the permutations at once, whereas the iterative method processes them one by one and has a lower space complexity.