Minimum Reverse Operations

Minimum Reverse Operations - Problem

You are given an integer n and an integer p representing an array arr of length n where all elements are set to 0's, except position p which is set to 1.

You are also given an integer array banned containing restricted positions and an integer k representing the size of subarrays you can reverse.

Operation: Reverse a subarray of size k if the single 1 is not at a position in banned.

Return an integer array answer with n results where the ith result is the minimum number of operations needed to bring the single 1 to position i in arr, or -1 if it is impossible.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Start at position 0. Position 1 and 2 are banned (-1). To reach position 3: reverse entire array [0,1,2,3] with k=4, moving element from position 0 to position 3 in 1 step.

Example 2 — No Banned Positions

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

› Output: [0,2,1]

💡 Note: Start at 0. Reverse [0,1,2] moves 0→2 (1 step). From 2, reverse [0,1,2] moves 2→0, then reverse moves 0→2→1 (2 steps total to reach 1).

Example 3 — Impossible Case

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

› Output: [0,1]

💡 Note: Start at 0. Reverse [0,1] with k=2 swaps positions, so 0→1 in 1 step. Both positions reachable.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ p < n
0 ≤ banned.length ≤ n - 1
0 ≤ banned[i] < n
banned[i] ≠ p
2 ≤ k ≤ n

Visualization

Tap to expand

Asked in

G Google 23 a Amazon 18 M Microsoft 15 f Meta 12

This problem asks to find the minimum operations to move a single 1 to each position using k-reversals. The key insight is modeling this as a shortest path problem where BFS finds optimal solutions. Best approach is BFS which explores reachable positions level by level. Time: O(n²), Space: O(n).

Common Approaches

✓ BFS Shortest Path

⏱️ Time: O(n²) Space: O(n)

Model this as a graph problem where each position is a node and edges represent valid k-reversals. Use BFS from starting position to find shortest path to all reachable positions.

Brute Force DFS

⏱️ Time: O(n × n!) Space: O(n²)

For each target position, use DFS to explore all possible sequences of k-reversals until we reach the target or exhaust all possibilities. Track visited states to avoid cycles.

BFS Shortest Path — Algorithm Steps

Start BFS from initial position p
For each position, generate all valid next positions via k-reversals
Skip banned positions and already visited positions
Record minimum steps when each position is first reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS from position p with step count 0

Expand

For each position, try all valid k-reversals

Record

First time reaching a position gives minimum steps

Code -

solution.c — C

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

typedef struct {
    int pos;
    int steps;
} QueueItem;

typedef struct {
    QueueItem* data;
    int front;
    int rear;
    int capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* queue = malloc(sizeof(Queue));
    queue->data = malloc(sizeof(QueueItem) * capacity);
    queue->front = 0;
    queue->rear = -1;
    queue->capacity = capacity;
    return queue;
}

void enqueue(Queue* queue, int pos, int steps) {
    queue->rear++;
    queue->data[queue->rear].pos = pos;
    queue->data[queue->rear].steps = steps;
}

QueueItem dequeue(Queue* queue) {
    return queue->data[queue->front++];
}

int isEmpty(Queue* queue) {
    return queue->front > queue->rear;
}

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int* solution(int n, int p, int* banned, int bannedSize, int k) {
    int* bannedSet = calloc(n, sizeof(int));
    for (int i = 0; i < bannedSize; i++) {
        if (banned[i] >= 0 && banned[i] < n) {
            bannedSet[banned[i]] = 1;
        }
    }
    
    int* result = malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) result[i] = -1;
    
    if (bannedSet[p]) {
        free(bannedSet);
        return result;
    }
    
    Queue* queue = createQueue(n * n);
    int* visited = calloc(n, sizeof(int));
    
    enqueue(queue, p, 0);
    visited[p] = 1;
    result[p] = 0;
    
    while (!isEmpty(queue)) {
        QueueItem current = dequeue(queue);
        int pos = current.pos;
        int steps = current.steps;
        
        for (int start = max(0, pos - k + 1); start <= min(n - k, pos); start++) {
            int newPos = start + (start + k - 1 - pos);
            
            if (newPos >= 0 && newPos < n && !bannedSet[newPos] && !visited[newPos]) {
                visited[newPos] = 1;
                result[newPos] = steps + 1;
                enqueue(queue, newPos, steps + 1);
            }
        }
    }
    
    for (int i = 0; i < bannedSize; i++) {
        if (banned[i] >= 0 && banned[i] < n) {
            result[banned[i]] = -1;
        }
    }
    
    free(bannedSet);
    free(visited);
    free(queue->data);
    free(queue);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int n, p, k;
    scanf("%d", &n);
    scanf("%d", &p);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    int banned[1000];
    int bannedSize = 0;
    if (strlen(line) > 2) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            banned[bannedSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    scanf("%d", &k);
    
    int* result = solution(n, p, banned, bannedSize, k);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each position can be visited once, and each visit generates O(n) next positions

⚠ Quadratic Growth

Space Complexity

O(n)

BFS queue and visited set store at most n positions

⚡ Linearithmic Space

21.5K Views

Medium Frequency

~35 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Shortest Path — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler