c++ 中排列的回溯

Question

I currently study permutations of a string where backtracking is used, and I am stuck at figuring out why does does this code goes back to i=0 when the function says it is on 1 for example, and so forth. But I do not understand a lot of this code so if anyone wants to help to explain this code to me I would be super thankful, thanks in advance!

#include <iostream>
using namespace std;

// Function to find all Permutations of a given string str[i..n-1]
// containing all distinct characters
void permutations(string str, int i, int n)
{
    // base condition
    if (i == n - 1)
    {
        cout << str << endl;
        return;
    }

    // process each character of the remaining string
    for (int j = i; j < n; j++)
    {
        // swap character at index i with current character
        swap(str[i], str[j]);        // STL swap() used

        // recur for string [i+1, n-1]
        permutations(str, i + 1, n);

        // backtrack (restore the string to its original state)
        swap(str[i], str[j]);
    }
}

// Find all Permutations of a string
int main()
{
    string str = "ABC";

    permutations(str, 0, str.length());

    return 0;
}

Answer 1

I'll go through the steps it's taking to print all the permutations of the string "ABC".

1 - You call the function with i = 0 .

2 - You enter the for loop and start with j = i .

3 - You swap str[0] with str[0] . (That does nothing).

4 - You recurse with i = i + 1 (i = 1).

5 - You enter the loop again but this time j = i = 1 .

6 - You swap str[1] with str[1] (That does nothing).

7 - You do recurse with i = 2 and str = "ABC" . Since i == n - 1 is true, this time you'll just print the result.

8 - You return from the call to the loop (with i = 1 ).

9 - You undo the swap that you've done before. Note that swapping the 2 elements twice is like doing nothing. In the first swap, the elements are swapped. In the second swap, the elements are back as they were before. In this case where i = j , You've swapped the same element with it self, so there is no effect form undoing what you did. But it'll be required when you swap 2 different characters.

10 - j gets incremented and becomes 2, and you swap str[1] with str[2] .

11 - You recurse again and call the function with i = 2 and str = "ACB" . Again, this time you'll just print the result.

I think you can deduce what will happen next and how the rest of the strings are formed.

If you wanna follow the whole steps you can read this:

Entered the function with i = 0 and str = ABC
    Swapping str[0] (A) with str[0] (A)
    str = ABC
    Entered the function with i = 1 and str = ABC
        Swapping str[1] (B) with str[1] (B)
        str = ABC
        Entered the function with i = 2 and str = ABC
            Printing the string ABC
        Swapping str[1] (B) with str[1] (B) to restore the original state of the string
        str = ABC
        Swapping str[1] (B) with str[2] (C)
        str = ABC
        Entered the function with i = 2 and str = ACB
            Printing the string ACB
        Swapping str[1] (C) with str[2] (B) to restore the original state of the string
        str = ABC
    Exiting the function with i = 1 and str = ABC
    Swapping str[0] (A) with str[0] (A) to restore the original state of the string
    str = ABC
    Swapping str[0] (A) with str[1] (B)
    str = ABC
    Entered the function with i = 1 and str = BAC
        Swapping str[1] (A) with str[1] (A)
        str = BAC
        Entered the function with i = 2 and str = BAC
            Printing the string BAC
        Swapping str[1] (A) with str[1] (A) to restore the original state of the string
        str = BAC
        Swapping str[1] (A) with str[2] (C)
        str = BAC
        Entered the function with i = 2 and str = BCA
            Printing the string BCA
        Swapping str[1] (C) with str[2] (A) to restore the original state of the string
        str = BAC
    Exiting the function with i = 1 and str = BAC
    Swapping str[0] (B) with str[1] (A) to restore the original state of the string
    str = ABC
    Swapping str[0] (A) with str[2] (C)
    str = ABC
    Entered the function with i = 1 and str = CBA
        Swapping str[1] (B) with str[1] (B)
        str = CBA
        Entered the function with i = 2 and str = CBA
            Printing the string CBA
        Swapping str[1] (B) with str[1] (B) to restore the original state of the string
        str = CBA
        Swapping str[1] (B) with str[2] (A)
        str = CBA
        Entered the function with i = 2 and str = CAB
            Printing the string CAB
        Swapping str[1] (A) with str[2] (B) to restore the original state of the string
        str = CBA
    Exiting the function with i = 1 and str = CBA
    Swapping str[0] (C) with str[2] (A) to restore the original state of the string
    str = ABC
Exiting the function with i = 0 and str = ABC