def minimum_jumps_to_reach_home_brute_force(start_position, forward_jump, backward_jump, home_position, forbidden_positions):
    queue = [(start_position, 0, False)] # (position, jumps, last_jump_backward)
    visited = set()
    visited.add((start_position, False))

    min_jumps = float('inf')

    while queue:
        current_position, number_of_jumps, last_jump_backward = queue.pop(0)

        if current_position == home_position:
            min_jumps = min(min_jumps, number_of_jumps)
            continue

        # We shouldn't explore paths longer than the minimum already found
        if number_of_jumps >= min_jumps:
            continue

        forward_position = current_position + forward_jump
        if (forward_position <= 6000) and (forward_position not in forbidden_positions) and ((forward_position, False) not in visited):
            queue.append((forward_position, number_of_jumps + 1, False))
            visited.add((forward_position, False))

        # We skip making a backward jump if we just made one
        if not last_jump_backward:
            backward_position = current_position - backward_jump
            # Must explore if we can move backward
            if (backward_position >= 0) and (backward_position not in forbidden_positions) and ((backward_position, True) not in visited):
                queue.append((backward_position, number_of_jumps + 1, True))
                visited.add((backward_position, True))

    if min_jumps == float('inf'):
        return -1
    else:
        return min_jumps

def minimum_jumps_to_reach_home(forbidden_positions, start_position, 
 forward_jump, backward_jump, home_position):
    forbidden_set = set(forbidden_positions)
    queue = [(start_position, 0, False)]
    visited = set()
    visited.add((start_position, False))
    farthest_reach = max(home_position + forward_jump, 
                         max(forbidden_positions) + forward_jump) + backward_jump

    while queue:
        current_position, jumps, went_backward = queue.pop(0)

        if current_position == home_position:
            return jumps

        # Explore forward jump
        next_position = current_position + forward_jump
        if (next_position <= farthest_reach and next_position not in forbidden_set 
            and (next_position, False) not in visited):

            queue.append((next_position, jumps + 1, False))
            visited.add((next_position, False))

        # Avoid jumping backward twice in a row
        if not went_backward:
            previous_position = current_position - backward_jump

            # Backward jump constraints
            if (previous_position >= 0 and previous_position not in forbidden_set
                and (previous_position, True) not in visited):

                # Mark True for went_backward to prevent consecutive backward jumps.
                queue.append((previous_position, jumps + 1, True))
                visited.add((previous_position, True))

    # Return -1 if home is unreachable
    return -1