Spiral Matrix IV - Practice Coding Problems

Spiral Matrix IV - Problem

Welcome to one of the most elegant matrix problems! 🌪️ You're tasked with creating a spiral matrix that combines linked list traversal with matrix manipulation.

Given:

Dimensions: Two integers m and n representing matrix size
Data source: Head of a linked list containing integers

Your mission: Generate an m × n matrix by placing linked list values in clockwise spiral order, starting from the top-left corner. Think of it as drawing a spiral from outside to inside!

🎯 Special rule: If you run out of linked list values before filling the entire matrix, fill remaining positions with -1.

Example: With a 3×3 matrix and linked list [3,0,2,6,8,1,7,9,4,2,5,5,0], you'd spiral clockwise: right → down → left → up → repeat until the center is reached.

Input & Output

example_1.py — Basic Spiral

$ Input: m = 3, n = 5, head = [3,0,2,6,8,1,7,9,4,2,5,5,0]

› Output: [[3,0,2,6,8],[5,0,-1,-1,1],[5,2,4,9,7]]

💡 Note: Starting from top-left, we spiral clockwise: first row (3→0→2→6→8), then right column (1→7), bottom row (9→4→2→5), left column (5), and finally the remaining center positions with linked list values or -1.

example_2.py — Perfect Fit

$ Input: m = 1, n = 4, head = [0,1,2]

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

💡 Note: Single row matrix: fill left to right with linked list values [0,1,2], then pad remaining position with -1.

example_3.py — Excess Values

$ Input: m = 2, n = 2, head = [1,2,3,4,5,6,7,8]

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

💡 Note: 2×2 matrix filled in spiral order: (0,0)→1, (0,1)→2, (1,1)→3, (1,0)→4. Extra linked list values (5,6,7,8) are ignored since matrix is full.

Constraints

1 ≤ m, n ≤ 10⁵
1 ≤ m × n ≤ 10⁵
The number of nodes in the list is in the range [1, m × n]
0 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Plant the Perimeter

Start at the northwest corner, plant along the north border (top row)

Move Down the East Side

Turn clockwise, plant down the east border (right column)

Cross the South Border

Turn clockwise again, plant across the south border (bottom row, right to left)

Up the West Side

Final turn, plant up the west border (left column, bottom to top)

Spiral Inward

Repeat the pattern for inner layers until the garden center is reached or flowers run out

Key Takeaway

🎯 Key Insight: By maintaining shrinking boundaries instead of checking individual positions, we create an elegant and efficient spiral traversal that mirrors natural growth patterns.

Asked in

G Google 85 f Meta 72 a Amazon 68 ⊞ Microsoft 45

The optimal solution uses a boundary-shrinking approach with O(m×n) time complexity. We maintain four boundaries (top, bottom, left, right) and systematically fill each layer of the spiral, shrinking boundaries after completing each side. This eliminates the need for direction checking and provides cleaner, more efficient code than the naive approach.

Common Approaches

Approach	Time	Space	Notes
✓ Layer-by-Layer Boundary Approach (Optimal)	O(m×n)	O(m×n)	Track four boundaries and shrink them as we complete each spiral layer
Direction Tracking with Boundary Checks	O(m×n)	O(m×n)	Track current position and direction, check boundaries and visited cells at each step

Layer-by-Layer Boundary Approach (Optimal) — Algorithm Steps

Initialize boundaries: top=0, bottom=m-1, left=0, right=n-1
Fill top row from left to right, then increment top boundary
Fill right column from top to bottom, then decrement right boundary
Fill bottom row from right to left, then decrement bottom boundary
Fill left column from bottom to top, then increment left boundary
Repeat until all boundaries collapse or linked list ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Boundaries

Set top=0, bottom=2, left=0, right=4 for 3×5 matrix

Fill Top Row

Fill (0,0) to (0,4), then shrink: top=1

Fill Right Column

Fill (1,4) to (2,4), then shrink: right=3

Fill Bottom Row

Fill (2,3) to (2,0), then shrink: bottom=1

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode *next;
};

int** spiralMatrix(int m, int n, struct ListNode* head, int* returnSize, int** returnColumnSizes) {
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    int** matrix = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        matrix[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
        for (int j = 0; j < n; j++) {
            matrix[i][j] = -1;
        }
    }
    
    int top = 0, bottom = m - 1;
    int left = 0, right = n - 1;
    struct ListNode* current = head;
    
    while (top <= bottom && left <= right && current) {
        // Fill top row (left to right)
        for (int col = left; col <= right && current; col++) {
            matrix[top][col] = current->val;
            current = current->next;
        }
        top++;
        
        // Fill right column (top to bottom)
        for (int row = top; row <= bottom && current; row++) {
            matrix[row][right] = current->val;
            current = current->next;
        }
        right--;
        
        // Fill bottom row (right to left)
        if (top <= bottom) {
            for (int col = right; col >= left && current; col--) {
                matrix[bottom][col] = current->val;
                current = current->next;
            }
            bottom--;
        }
        
        // Fill left column (bottom to top)
        if (left <= right) {
            for (int row = bottom; row >= top && current; row--) {
                matrix[row][left] = current->val;
                current = current->next;
            }
            left++;
        }
    }
    
    return matrix;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    
    char* token = strtok(line, " \n");
    while (token) {
        int val = atoi(token);
        struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
        newNode->val = val;
        newNode->next = NULL;
        
        if (!head) {
            head = tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
        token = strtok(NULL, " \n");
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = spiralMatrix(m, n, head, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell exactly once in the optimal spiral order

✓ Linear Growth

Space Complexity

O(m×n)

Space only for the result matrix

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Layer-by-Layer Boundary Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler