Spiral Matrix III - Practice Coding Problems

Spiral Matrix III - Problem

Spiral Matrix III - Navigate in a Clockwise Spiral Pattern

Imagine you're a robot starting at position (rStart, cStart) in an rows × cols grid, initially facing east. Your mission is to walk in a clockwise spiral pattern to visit every single cell in the grid.

Here's the twist: you're allowed to walk outside the grid boundaries! When you step outside, you continue your spiral journey in the void, but you might re-enter the grid later. Think of it like walking on an infinite plane where only certain cells (the original grid) matter.

Goal: Return an array of coordinates representing the order in which you visit each cell within the original grid.

Spiral Pattern: East → South → West → North → East (repeat)
Step Pattern: 1 step east, 1 step south, 2 steps west, 2 steps north, 3 steps east, 3 steps south, 4 steps west, 4 steps north, ...

The number of steps increases every two direction changes!

Input & Output

example_1.py — Basic 1x4 Grid

$ Input: rows = 1, cols = 4, rStart = 0, cStart = 0

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

💡 Note: Starting at (0,0) facing east, we move right through the single row: (0,0) → (0,1) → (0,2) → (0,3). The spiral naturally visits all cells in order.

example_2.py — 5x6 Grid from Center

$ Input: rows = 5, cols = 6, rStart = 1, cStart = 4

› Output: [[1,4],[1,5],[2,5],[2,4],[2,3],[1,3],[0,3],[0,4],[0,5],[3,5],[3,4],[3,3],[3,2],[2,2],[1,2],[0,2],[4,5],[4,4],[4,3],[4,2],[4,1],[3,1],[2,1],[1,1],[0,1],[4,0],[3,0],[2,0],[1,0],[0,0]]

💡 Note: Starting at (1,4), the spiral expands outward: 1 step east to (1,5), 1 step south to (2,5), 2 steps west to (2,4) then (2,3), 2 steps north to (1,3) then (0,3), and so on. The pattern continues until all 30 cells are visited.

example_3.py — Single Cell Grid

$ Input: rows = 1, cols = 1, rStart = 0, cStart = 0

› Output: [[0,0]]

💡 Note: Edge case with only one cell. We start and end at (0,0) since there's nowhere else to go.

Constraints

1 ≤ rows, cols ≤ 100
0 ≤ rStart < rows
0 ≤ cStart < cols
Grid size is manageable - maximum 10,000 cells

Visualization

Tap to expand

Understanding the Visualization

Initialize at Starting Position

Begin at (rStart, cStart) facing east, ready to start our spiral journey

Follow 1-1-2-2 Pattern

Move 1 step east, 1 step south, 2 steps west, 2 steps north

Expand to 3-3-4-4 Pattern

Continue with 3 steps east, 3 steps south, 4 steps west, 4 steps north

Record Valid Positions Only

Only add coordinates to result when they fall within the original grid boundaries

Key Takeaway

🎯 Key Insight: The spiral follows a predictable expanding pattern where step counts increase every two direction changes, making it easy to simulate without complex calculations.

Asked in

G Google 45 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal approach is spiral simulation with direction tracking. Follow the natural spiral pattern: start facing east, move in expanding squares with step counts (1,1,2,2,3,3,4,4...), and only record positions within grid boundaries. Key insight: Steps increase every 2 direction changes, creating the characteristic expanding spiral shape.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with Direction Tracking	O(max(rows, cols)²)	O(rows × cols)	Simulate the spiral walk step by step, tracking direction changes and step counts

Simulation with Direction Tracking — Algorithm Steps

Start at (rStart, cStart) facing east with step count = 1
Move in current direction for the required number of steps
For each position, check if it's within grid bounds and record it
After completing steps in current direction, turn clockwise
Increase step count every two direction changes
Continue until we've visited all rows × cols cells

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at (1,4) facing East

Begin the spiral journey at the starting position

1 step East, 1 step South

First spiral segment with 1 step each direction

2 steps West, 2 steps North

Second spiral segment with 2 steps each direction

Continue expanding pattern

Pattern continues with 3,3,4,4,5,5... steps

Code -

solution.c — C

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

int** spiralMatrixIII(int rows, int cols, int rStart, int cStart, int* returnSize, int** returnColumnSizes) {
    // Directions: East, South, West, North
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    int** result = (int**)malloc(rows * cols * sizeof(int*));
    *returnColumnSizes = (int*)malloc(rows * cols * sizeof(int));
    
    int r = rStart, c = cStart;
    int direction = 0; // Start facing East
    int steps = 1;
    int count = 0;
    
    // Add starting position if valid
    if (r >= 0 && r < rows && c >= 0 && c < cols) {
        result[count] = (int*)malloc(2 * sizeof(int));
        result[count][0] = r;
        result[count][1] = c;
        (*returnColumnSizes)[count] = 2;
        count++;
    }
    
    while (count < rows * cols) {
        for (int i = 0; i < 2; i++) { // Each step count used for 2 directions
            int dr = directions[direction][0];
            int dc = directions[direction][1];
            for (int j = 0; j < steps; j++) {
                r += dr;
                c += dc;
                if (r >= 0 && r < rows && c >= 0 && c < cols) {
                    result[count] = (int*)malloc(2 * sizeof(int));
                    result[count][0] = r;
                    result[count][1] = c;
                    (*returnColumnSizes)[count] = 2;
                    count++;
                }
            }
            direction = (direction + 1) % 4; // Turn clockwise
        }
        steps++; // Increase steps after every 2 direction changes
    }
    
    *returnSize = count;
    return result;
}

int main() {
    int rows, cols, rStart, cStart;
    scanf("%d %d %d %d", &rows, &cols, &rStart, &cStart);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = spiralMatrixIII(rows, cols, rStart, cStart, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(rows, cols)²)

In worst case, we may need to spiral far outside the grid. The spiral area grows quadratically with distance from center.

✓ Linear Growth

Space Complexity

O(rows × cols)

We store the result array containing all grid positions, plus O(1) for tracking variables.

✓ Linear Space

24.5K Views

Medium Frequency

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

Simulation with Direction Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler