Update README.md

Author: djeada

src/backtracking/python/all_permutations/README.md

@@ -1,8 +1,6 @@
-## Generating all permutations of a list of elements
+## Generating All Permutations of a List
 
-Given a list of elements, the problem is to generate all possible permutations of these elements.
-
-For example, if the input list is `[1, 2, 3]`, the possible permutations are:
+Given a list of *n* distinct elements, the goal is to produce every possible ordering (permutation) of those elements. For example, if the input is `[1, 2, 3]`, the six permutations are:
 
 ```
 [1, 2, 3]
@@ -13,22 +11,105 @@ For example, if the input list is `[1, 2, 3]`, the possible permutations are:
 [3, 2, 1]
 ```
 
-##  Approach
+Because there are *n!* permutations of *n* items, any algorithm will inevitably take at least *O(n!)* time just to enumerate them. In practice, two common ways to generate all permutations in Python are:
+
+1. **Using a built-in library function (e.g., `itertools.permutations`)**
+2. **Writing a pure-Python backtracking routine**
+
+Below is a conceptual overview of each approach, along with its time complexity and a brief discussion of advantages and trade-offs.
+
+---
+
+### 1. Built-in Permutations (Conceptual)
+
+Most languages have a library routine that directly yields all permutations of a sequence in an efficient, low-level implementation. In Python, for instance, `itertools.permutations` returns every ordering as a tuple. Converting those tuples to lists (if needed) simply costs an extra *O(n)* per permutation.
+
+* **Core idea**
+
+  * Defer the heavy lifting to a built-in routine that is usually implemented in C (or another compiled language).
+  * Each call to the library function produces one permutation in constant (amortized) time.
+  * If you need the result as lists instead of tuples, you convert each tuple to a list before collecting it.
+
+* **Time Complexity**
+
+  * There are *n!* total permutations.
+  * Generating each tuple is effectively *O(1)* (amortized), but converting to a list of length *n* costs *O(n)*.
+  * Overall: **O(n! · n)**.
+
+* **Pros**
+
+  * Very concise—just a single function call.
+  * Relies on a battle-tested standard library implementation.
+  * Highly optimized in C under the hood.
+
+* **Cons**
+
+  * Still incurs the *O(n)* conversion for each permutation if you need lists.
+  * Less educational (you don’t see how the algorithm actually works).
+
+---
+
+### 2. In-Place Backtracking (Conceptual)
+
+A backtracking algorithm builds each permutation by swapping elements in the original list in place, one position at a time. Once every position is “fixed,” you record a copy of the list in that order. Then you swap back and proceed to the next possibility.
+
+* **Core idea (pseudocode)**
+
+  1. Let the input list be `A` of length *n*.
+  2. Define a recursive routine `backtrack(pos)` that means “choose which element goes into index `pos`.”
+  3. If `pos == n`, then all indices are filled—append a copy of `A` to the results.
+  4. Otherwise, for each index `i` from `pos` to `n−1`:
+
+     * Swap `A[pos]` and `A[i]`.
+     * Recursively call `backtrack(pos + 1)`.
+     * Swap back to restore the original order before trying the next `i`.
+
+* **Time Complexity**
+
+  * Exactly *n!* permutations will be generated.
+  * Each time you reach `pos == n`, you copy the current list (cost *O(n)*).
+  * Swapping elements is *O(1)*, and there are lower-order operations for looping.
+  * Overall: **O(n! · n)**.
+
+* **Pros**
+
+  * Pure-Python and fairly straightforward to implement once you understand swapping + recursion.
+  * Does not require constructing new intermediate lists at every recursive call—only one final copy per permutation.
+  * In-place swapping keeps overhead minimal (aside from the final copy).
+
+* **Cons**
+
+  * A bit more code and recursion overhead.
+  * Uses recursion up to depth *n* (though that is usually acceptable unless *n* is quite large).
+  * Easier to make an off-by-one mistake if you forget to swap back.
+
+---
+
+## Time Complexity (Both Approaches)
+
+No matter which method you choose, you must generate all *n!* permutations and produce them as lists/arrays. Since each complete permutation takes at least *O(n)* time to output or copy, the combined runtime is always:
+
+```
+O(n! · n)
+```
+
+* *n!* choices of permutation
+* Copying or formatting each permutation (length n) costs an extra n
 
-One approach to solve this problem is to use a backtracking algorithm.
+---
 
-A backtracking algorithm works by starting with an empty list and adding elements to it one at a time, then exploring the resulting permutations, and backtracking (removing the last added element) when it is no longer possible to generate new permutations.
+## When to Use Each Approach
 
-To implement the backtracking algorithm, we can use a recursive function that takes two arguments:
+* **Built-in library function**
 
-* `input_list`: the list of elements from which the permutations are generated.
-* `output_list`: the current permutation being generated.
+  * Ideal if you want minimal code and maximum reliability.
+  * Use whenever your language provides a standard “permutations” routine.
+  * Particularly helpful if you only need to iterate lazily over permutations (you can yield one tuple at a time).
 
-The function can follow these steps:
+* **In-place backtracking**
 
-* If the length of `output_list` is equal to the length of `input_list`, it means that a permutation of all the elements has been found. In this case, the function can append the permutation to a list of results and return.
-* If the length of `output_list` is not equal to the length of `input_list`, the function can enter a loop that enumerates the elements of the input list.
-* For each element, the function can check if it is present in the `output_list`. If the element is not present, the function can call itself recursively with `input_list and output_list + [element]` (to add the element to the permutation).
-* After the loop, the function can return the list of results.
+  * Educational: you see how swapping and recursion produce every ordering.
+  * Useful if you need to integrate custom pruning or constraints (e.g., skip certain permutations early).
+  * Allows you to avoid tuple-to-list conversions if you directly output lists, although you still pay an *O(n)* copy cost per permutation.
 
-The time complexity of this approach is $O(n! * n)$, where n is the length of the input list.
+In most practical scenarios—unless you have a specialized constraint or want to illustrate the algorithm—using the built-in routine is recommended for brevity and performance. However, if you need to customize the traversal (e.g., skip certain branches), an in-place backtracking solution makes it easy to check conditions before fully expanding each branch.