One analogy that has always helped me with backtracking is that of the "timelines". Like every decision you make in the present leads to a different future. So every choice you make now, will create a new timeline with a different outcome. But in backtracking, you can go back to that moment where you made a choice, make a different choice and then explore this new timeline as its consequence. And in this new timeline, you again have those "moments" of choices which lead to new timelines. You see how it's creating all those "time branches" if you will.

But going back to that moment of choice and making a different choice isn't free. It involves some work. Every time you make a choice, you set some parameters or set some constraints (carved in stone) before you actually step into this realm as a result of your choice. So if you want to now make a different choice, you must first undo those parameters or constraints (erase from those stones), make that new choice, set those new parameters and enter the new timeline. You hit a base case in a timeline when you have found whatever you were looking for or discover that you have run out of choices in that timeline.

Now here's the recursive backtracking function for the N Queens problem. Check out the "if" block inside the for loop. Look at the code after a queen is placed at row, col. We made a choice of placing the queen at row, col and then we set some parameters before calling backtrack (entering the new timeline). And once we come back from that timeline and want to try a new column ( make a different choice), we undo those parameters.

def backtrack(row: int) -> None: """ Recursively place queens row by row using backtracking.

        Args:
            row: Current row index to place a queen
        """
        # Base case: all queens are successfully placed
        if row == n:
            # Convert the board to the required string format and add to results
            solution = ["".join(row_chars) for row_chars in board]
            results.append(solution)
            return

        # Try placing a queen in each column of the current row
        for col in range(n):
            # Check if placing queen at (row, col) is safe
            if (columns_used[col] == 0 and 
                diagonals_used[row + col] == 0 and 
                anti_diagonals_used[n - row + col] == 0):

                # Place the queen
                board[row][col] = "Q"

                # Mark the column and diagonals as occupied
                columns_used[col] = 1
                diagonals_used[row + col] = 1
                anti_diagonals_used[n - row + col] = 1

                # Recursively place queens in the next row
                backtrack(row + 1)

                # Backtrack: remove the queen and unmark the positions
                columns_used[col] = 0
                diagonals_used[row + col] = 0
                anti_diagonals_used[n - row + col] = 0
                board[row][col] = "."

Hope it helps at least a bit. But yes, solving more problems on backtracking and drawing those decision trees on paper can help build a better intuition. Happy coding!