Minimum Reverse Operations - Practice Coding Problems

Minimum Reverse Operations - Problem

🔄 Minimum Reverse Operations

You're given an array of length n filled with zeros, except for one single position p that contains a 1. Think of this as a token that you need to move around the array.

Your mission: Move this token to every possible position in the array using a special operation - you can reverse any subarray of length k, but only if the token (the 1) won't land on a banned position.

Goal: Return an array where result[i] is the minimum number of operations needed to move the token to position i, or -1 if it's impossible.

Example: If n=4, p=0, k=3, banned=[1,2], you start with [1,0,0,0] and can reverse subarrays of length 3, but the token cannot land on positions 1 or 2.

Input & Output

example_1.py — Basic Case

$ Input: n = 4, p = 0, banned = [1, 2], k = 4

› Output: [0, -1, -1, 1]

💡 Note: Start with token at position 0. With k=4, we can reverse the entire array [1,0,0,0] → [0,0,0,1], moving token to position 3 in 1 step. Positions 1 and 2 are banned and unreachable.

example_2.py — Multiple Steps

$ Input: n = 5, p = 0, banned = [2, 4], k = 3

› Output: [0, 2, -1, 1, -1]

💡 Note: Starting at 0: reverse [0,1,2] gets us to position 2, but it's banned. We can reach position 3 in 1 step by reversing [0,1,2] to move to position 2, then position 1 in 2 steps. Positions 2 and 4 remain unreachable.

example_3.py — Edge Case

$ Input: n = 3, p = 1, banned = [], k = 3

› Output: [2, 0, 2]

💡 Note: Start with token at position 1. Can reverse entire array [0,1,0] → [0,1,0] (no change) or shift positions. Need 2 operations to reach positions 0 and 2.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ p < n
0 ≤ banned.length ≤ n - 1
0 ≤ banned[i] < n
1 ≤ k ≤ n
All values in banned are unique
p is not in banned

Visualization

Tap to expand

Understanding the Visualization

Initial State

Token starts at position p, with some positions banned (marked in red)

First Moves

Apply reverse operations of length k to reach new positions in 1 step

Expand Search

From each new position, continue exploring to find positions reachable in 2 steps

Complete Map

Continue until all reachable positions are found with minimum steps

Key Takeaway

🎯 Key Insight: Model as shortest path in implicit graph where BFS guarantees minimum operations, using parity optimization for efficient transitions

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses BFS (Breadth-First Search) to model this as a shortest path problem in an implicit graph. Each array position is a node, and valid reverse operations create edges. The key optimization uses parity-based sets to efficiently find valid transitions, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ BFS (Optimal)	O(n)	O(n)	Use BFS to find minimum operations to reach each position in the graph
Brute Force DFS with Backtracking	O(k^n)	O(n)	Try all possible sequences of operations using DFS to find minimum steps to each position

BFS (Optimal) — Algorithm Steps

Create sets to track banned positions and reachable positions
Initialize BFS queue with starting position p at distance 0
For each position in queue, calculate all possible new positions after reverse operation
Add unvisited, non-banned positions to queue with incremented distance
Use two sets (even/odd parity) to optimize finding valid transitions
Continue until all reachable positions are explored

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS from position p with 0 operations

Level 1

Explore all positions reachable in 1 operation

Level 2

Explore all positions reachable in 2 operations

Continue

Continue until all reachable positions found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* minReverseOperations(int n, int p, int* banned, int bannedSize, int k, int* returnSize) {
    int* bannedSet = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < bannedSize; i++) {
        bannedSet[banned[i]] = 1;
    }
    
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = -1;
    }
    result[p] = 0;
    
    int* evenPositions = (int*)calloc(n, sizeof(int));
    int* oddPositions = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        if (!bannedSet[i]) {
            if (i % 2 == 0) {
                evenPositions[i] = 1;
            } else {
                oddPositions[i] = 1;
            }
        }
    }
    
    int* queue = (int*)malloc(n * sizeof(int));
    int front = 0, rear = 0;
    
    queue[rear++] = p;
    if (p % 2 == 0) {
        evenPositions[p] = 0;
    } else {
        oddPositions[p] = 0;
    }
    
    while (front < rear) {
        int pos = queue[front++];
        
        int left = (0 > (pos - k + 1 > pos + k - 1 - (n - 1) ? pos - k + 1 : pos + k - 1 - (n - 1))) ? 
                   (pos - k + 1 > pos + k - 1 - (n - 1) ? pos - k + 1 : pos + k - 1 - (n - 1)) : 0;
        int right = (pos < n - k) ? pos : n - k;
        
        int newLeft = left + k - 1 - (pos - left);
        int newRight = right + k - 1 - (pos - right);
        
        int* targetSet = ((k + pos) % 2 == 0) ? evenPositions : oddPositions;
        
        for (int nextPos = newLeft; nextPos <= newRight; nextPos++) {
            if (targetSet[nextPos]) {
                result[nextPos] = result[pos] + 1;
                queue[rear++] = nextPos;
                targetSet[nextPos] = 0;
            }
        }
    }
    
    free(bannedSet);
    free(evenPositions);
    free(oddPositions);
    free(queue);
    
    *returnSize = n;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is visited at most once, and for each position we do O(1) work to find next positions

✓ Linear Growth

Space Complexity

O(n)

Space for queue, visited sets, and result array

⚡ Linearithmic Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🔄 Minimum Reverse Operations

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler