The Standoff.

How backtracking thinks — four moves

1. One choice at a time. Fill columns left to right; each column needs exactly one queen, in some row.
2. Check before you commit. A row is safe only if no placed queen shares that row or either diagonal.
3. Place & recurse. On a safe square, place the queen and solve the next column. Success there means success here.
4. Dead end? Undo. If no row in a column is safe, remove the previous queen and try its next row — backtrack.

The whole thing in code

def solve(n):
    pos = [-1] * n          # pos[col] = row of its queen

    def safe(col, row):
        for c in range(col):
            r = pos[c]
            if r == row or abs(r - row) == abs(c - col):
                return False     # same row or diagonal
        return True

    def place(col):
        if col == n:
            return True          # all columns filled - solved
        for row in range(n):
            if safe(col, row):
                pos[col] = row   # choose
                if place(col + 1):
                    return True  # recurse
                pos[col] = -1    # UNDO - backtrack
        return False

    return pos if place(0) else None