def open_the_lock_brute_force(deadends, target):
    initial_combination = '0000'

    if initial_combination in deadends:
        return -1

    visited_combinations = {initial_combination}
    queue = [initial_combination]
    number_of_steps = 0

    while queue:
        queue_length = len(queue)

        for _ in range(queue_length):
            current_combination = queue.pop(0)

            if current_combination == target:
                return number_of_steps

            # Explore all possible next combinations
            for index in range(4):
                digit = int(current_combination[index])
                
                # Try incrementing the digit
                incremented_combination = current_combination[:index] + str((digit + 1) % 10) + current_combination[index+1:]
                if incremented_combination not in deadends and incremented_combination not in visited_combinations:
                    queue.append(incremented_combination)
                    visited_combinations.add(incremented_combination)

                # Try decrementing the digit
                decremented_combination = current_combination[:index] + str((digit - 1 + 10) % 10) + current_combination[index+1:]
                if decremented_combination not in deadends and decremented_combination not in visited_combinations:
                    # Ensure that the next combination is valid
                    queue.append(decremented_combination)
                    visited_combinations.add(decremented_combination)

        number_of_steps += 1

    return -1

def open_the_lock(dead_ends, target):
    start_combination = "0000"
    if start_combination in dead_ends:
        return -1

    queue = [(start_combination, 0)]
    visited = {start_combination}

    while queue:
        current_combination, moves = queue.pop(0)

        if current_combination == target:
            return moves

        # Iterate through each digit in the combination.
        for index in range(4):
            digit = int(current_combination[index])

            # Generate the next possible combination by incrementing
            incremented_digit = (digit + 1) % 10
            incremented_combination = current_combination[:index] + str(incremented_digit) + current_combination[index + 1:]
            if incremented_combination not in visited and incremented_combination not in dead_ends:

                # Avoid revisiting combinations.
                visited.add(incremented_combination)
                queue.append((incremented_combination, moves + 1))

            # Generate the next possible combination by decrementing
            decremented_digit = (digit - 1 + 10) % 10
            decremented_combination = current_combination[:index] + str(decremented_digit) + current_combination[index + 1:]
            if decremented_combination not in visited and decremented_combination not in dead_ends:
                # Avoid revisiting combinations.
                visited.add(decremented_combination)
                queue.append((decremented_combination, moves + 1))

    # If target not reachable
    return -1