Minimum Moves to Reach Target with Rotations

Minimum Moves to Reach Target with Rotations - Problem

In an n×n grid, there is a snake that spans 2 cells and starts at the top-left corner at positions (0, 0) and (0, 1). The grid has empty cells represented by 0 and blocked cells represented by 1.

The snake wants to reach the target at the lower-right corner at positions (n-1, n-2) and (n-1, n-1).

In one move, the snake can:

Move right: Move one cell to the right if there are no blocked cells there
Move down: Move one cell down if there are no blocked cells there
Rotate clockwise: If in horizontal position and the two cells under it are both empty, snake moves from (r, c), (r, c+1) to (r, c), (r+1, c)
Rotate counterclockwise: If in vertical position and the two cells to its right are both empty, snake moves from (r, c), (r+1, c) to (r, c), (r, c+1)

Return the minimum number of moves to reach the target. If there is no way to reach the target, return -1.

Input & Output

Example 1 — Basic Case

$ Input: grid = [[0,0,0,0,0,1],[1,1,0,0,1,0],[0,0,0,0,1,1],[0,0,1,0,1,0],[0,1,1,0,0,0],[0,1,1,0,0,0]]

› Output: 11

💡 Note: Snake starts at (0,0)-(0,1) horizontal and needs to reach (5,4)-(5,5). Through a series of moves and rotations, minimum 11 moves are needed.

Example 2 — Simple Grid

$ Input: grid = [[0,0,1,1,1,1],[0,0,0,0,1,1],[1,1,0,0,0,1],[1,1,1,0,0,0],[0,1,1,0,0,0],[0,1,1,0,0,0]]

› Output: -1

💡 Note: Snake cannot reach the target due to blocked paths, so return -1.

Example 3 — Small Grid

$ Input: grid = [[0,0,0],[0,1,0],[0,0,0]]

› Output: 4

💡 Note: In a 3×3 grid, snake needs 4 moves: right, rotate, down, rotate to reach (2,1)-(2,2).

Constraints

2 ≤ n ≤ 100
grid.length == n
grid[i].length == n
grid[i][j] is 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

This problem requires finding the shortest path for a 2-cell snake in a grid. The key insight is to model each snake configuration as a state (position + orientation) and use BFS to guarantee minimum moves. The snake can move right/down or rotate when conditions allow. Best approach uses BFS with state tracking. Time: O(n²), Space: O(n²)

Common Approaches

✓ BFS with State Tracking

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

Model each snake configuration as a state (position + orientation) and use BFS to systematically explore all reachable states. BFS guarantees the first path found to the target uses minimum moves.

Brute Force DFS

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

Recursively explore every possible move (right, down, rotate) from each position and orientation until reaching the target. Track visited states to avoid cycles.

BFS with State Tracking — Algorithm Steps

Start with initial state in queue
For each state, try all valid moves
Add new states to queue, track visited to avoid cycles
Return moves when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Queue

Start with snake at (0,0)-(0,1) horizontal

Level Expansion

Process each state, add valid moves to queue

Target Found

Return moves when target state is reached

Code -

solution.c — C

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

struct State {
    int r1, c1, r2, c2, moves;
};

struct Queue {
    struct State* data;
    int front, rear, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->data = (struct State*)malloc(capacity * sizeof(struct State));
    q->front = q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(struct Queue* q, struct State state) {
    q->data[q->rear++] = state;
}

struct State dequeue(struct Queue* q) {
    return q->data[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

struct VisitedNode {
    int r1, c1, r2, c2;
    struct VisitedNode* next;
};

struct VisitedNode* visited = NULL;

int isVisited(int r1, int c1, int r2, int c2) {
    struct VisitedNode* curr = visited;
    while (curr) {
        if (curr->r1 == r1 && curr->c1 == c1 && curr->r2 == r2 && curr->c2 == c2) {
            return 1;
        }
        curr = curr->next;
    }
    return 0;
}

void addVisited(int r1, int c1, int r2, int c2) {
    struct VisitedNode* newNode = (struct VisitedNode*)malloc(sizeof(struct VisitedNode));
    newNode->r1 = r1;
    newNode->c1 = c1;
    newNode->r2 = r2;
    newNode->c2 = c2;
    newNode->next = visited;
    visited = newNode;
}

int solution(int** grid, int n) {
    struct Queue* queue = createQueue(100000);
    visited = NULL;
    
    struct State start = {0, 0, 0, 1, 0};
    enqueue(queue, start);
    addVisited(0, 0, 0, 1);
    
    while (!isEmpty(queue)) {
        struct State curr = dequeue(queue);
        
        if (curr.r1 == n-1 && curr.c1 == n-2 && curr.r2 == n-1 && curr.c2 == n-1) {
            return curr.moves;
        }
        
        struct State candidates[4];
        int candidateCount = 0;
        
        // Check if currently horizontal or vertical
        int isHorizontal = (curr.r1 == curr.r2);
        int isVertical = (curr.c1 == curr.c2);
        
        if (isHorizontal) {
            // Snake is horizontal: (r, c) and (r, c+1)
            // Move right
            if (curr.c2 + 1 < n && grid[curr.r1][curr.c2+1] == 0) {
                candidates[candidateCount++] = (struct State){curr.r1, curr.c1+1, curr.r2, curr.c2+1, curr.moves+1};
            }
            
            // Move down
            if (curr.r1 + 1 < n && grid[curr.r1+1][curr.c1] == 0 && grid[curr.r2+1][curr.c2] == 0) {
                candidates[candidateCount++] = (struct State){curr.r1+1, curr.c1, curr.r2+1, curr.c2, curr.moves+1};
            }
            
            // Rotate clockwise (horizontal to vertical)
            if (curr.r1 + 1 < n && grid[curr.r1+1][curr.c1] == 0 && grid[curr.r1+1][curr.c2] == 0) {
                candidates[candidateCount++] = (struct State){curr.r1, curr.c1, curr.r1+1, curr.c1, curr.moves+1};
            }
        } else if (isVertical) {
            // Snake is vertical: (r, c) and (r+1, c)
            // Move right
            if (curr.c1 + 1 < n && grid[curr.r1][curr.c1+1] == 0 && grid[curr.r2][curr.c2+1] == 0) {
                candidates[candidateCount++] = (struct State){curr.r1, curr.c1+1, curr.r2, curr.c2+1, curr.moves+1};
            }
            
            // Move down
            if (curr.r2 + 1 < n && grid[curr.r2+1][curr.c2] == 0) {
                candidates[candidateCount++] = (struct State){curr.r1+1, curr.c1, curr.r2+1, curr.c2, curr.moves+1};
            }
            
            // Rotate counterclockwise (vertical to horizontal)
            if (curr.c1 + 1 < n && grid[curr.r1][curr.c1+1] == 0 && grid[curr.r2][curr.c1+1] == 0) {
                candidates[candidateCount++] = (struct State){curr.r1, curr.c1, curr.r1, curr.c1+1, curr.moves+1};
            }
        }
        
        for (int i = 0; i < candidateCount; i++) {
            struct State candidate = candidates[i];
            if (!isVisited(candidate.r1, candidate.c1, candidate.r2, candidate.c2)) {
                addVisited(candidate.r1, candidate.c1, candidate.r2, candidate.c2);
                enqueue(queue, candidate);
            }
        }
    }
    
    return -1;
}

static int grid_data[100][100];
static int* grid_ptrs[100];

int main() {
    // Initialize grid pointers
    for (int i = 0; i < 100; i++) {
        grid_ptrs[i] = grid_data[i];
    }
    
    // Read input line
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        printf("-1\n");
        return 0;
    }
    
    // Parse grid size and data
    int n = 0;
    char* ptr = line + 1; // skip first '['
    
    while (*ptr) {
        if (*ptr == '[') {
            ptr++; // skip '['
            int col = 0;
            char num[10];
            int numIdx = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    num[numIdx++] = *ptr;
                } else if (*ptr == ',' && numIdx > 0) {
                    num[numIdx] = '\0';
                    grid_data[n][col++] = strtol(num, NULL, 10);
                    numIdx = 0;
                }
                ptr++;
            }
            if (numIdx > 0) {
                num[numIdx] = '\0';
                grid_data[n][col++] = strtol(num, NULL, 10);
            }
            n++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(grid_ptrs, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each cell can be visited in at most 2 states (horizontal/vertical), so total states are 2×n²

⚠ Quadratic Growth

Space Complexity

O(n²)

Queue and visited set store up to 2×n² states

⚠ Quadratic Space

32.0K Views

Medium Frequency

~35 min Avg. Time

853 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 with State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler