Permutations

Generating permutation is a really expensive algorithm
Why?
Why would we do this?
What will the order be? (Minimal)
There are a number of algorithms to do this.
A decrease by one algorithm would be
- For a set of n elements,
- Remove one item.
- Generate all permutations of a n-1 set of elements.
- Insert the item into all possible locations in the set returned.
- Consider permuting {a,b,c,d}
- ```
{a,b,c,d} => [a, {b,c,d}]
     {b,c,d} => [b, {c,d}]
          {c,d} => [c, {d}]
               {d} => [ d]
	        => [ cd, dc]
	     => [bcd, cbd, cdb, bdc, dbc, dcb]
	   => [abcd, bacd, bcad, bcda, acbd, cabd, cbad, cbda, ...dcba]
	 
```
- This satisfies the minimal change requirement: each permutation can be obtained from its immediate predecessor by exchanging just two elements in it.
- Unfortunately, we are required to store all permutations for this algorithm to work.

Johnson Trotter

Associated with each item is an arrow, (left or right)
I will use 2^← to represent item two pointed to the left.
The book draws arrows over the items, but this is too much in html.
An item is mobile if the arrow points to a smaller number.
in 3^→2^←4^→1^←, 3 and 4 are mobile, since 3 points to 2 and 4 points to 1

JOHNSON_TROTTER(n)

 Initialize the first permutation to 1l2l3l...nl
 while the last permutation has a mobile element do
     find the largest mobile element k
     swap k with the adjacent elements k's arrow points to
     reverse the direction of all of the elements that are larger than k
     add the new permutation to the list

For n=3, this would produce

1^← 2^← 3^←  -> 1^← 3^← 2^←
1^← 3^← 2^←  -> 3^← 1^← 2^←
3^← 1^← 2^←  -> 3^→ 2^← 1^←
3^→ 2^← 1^←  -> 2^← 3^→ 1^←
2^← 3^→ 1^←  -> 2^← 1^← 3^→
2^← 1^← 3^→ -> DONE

The next_permutation algorithm in the STL preserves lexicographic order.

This means that if the permutations were listed in a dictionary, the next permutation is the next one in that order.
This is not the case with JohnsonTrotter.
But it is with this algorithm

LEXICOGRAPHIC_PERMUTE(n)

 initialize the first permutation with 1234...n
 while last permutation has two consecutive elements in increasing order do
     let i be the largest index such that a_i < a_i+1
     find the largest index j such that a_i < a_j
     swap(a_i, a_j)
     reverse the order of a_i+1 to a_n
     add the new permutation to the list.

for 123 it would produce

123 ->  132 -> 132
132 -> 231 -> 213
213 ->  231 -> 231
231 -> 321 -> 312 
312 ->  321 -> 321
321 -> DONE, exit condition met