Spiral Matrix IV

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

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

✓ Direction Tracking with Boundary Checks

⏱️ Time: O(m×n) Space: O(m×n)

This approach simulates the spiral movement by maintaining current position (row, col) and direction. At each step, we try to continue in the current direction. If we hit a boundary or an already filled cell, we turn clockwise and continue. We use a visited matrix or check for non-default values to know which cells are filled.

Layer-by-Layer Boundary Approach (Optimal)

⏱️ Time: O(m×n) Space: O(m×n)

Instead of checking individual cells, this approach maintains four boundaries (top, bottom, left, right) and systematically fills each layer of the spiral. After completing each side, we shrink the corresponding boundary. This eliminates the need for direction vectors and boundary checking at every cell.

Direction Tracking with Boundary Checks — Algorithm Steps

Initialize result matrix with -1 values
Start at position (0,0) going RIGHT
For each linked list node, place value at current position
Try to move in current direction
If blocked (boundary/filled cell), turn clockwise
Continue until linked list is exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at (0,0) facing RIGHT with first linked list value

Move Forward

Continue in current direction while path is clear

Hit Boundary

Detect boundary or filled cell, turn clockwise

Continue Spiral

Repeat until linked list is exhausted

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));
    
    // Initialize matrix with -1
    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;
        }
    }
    
    // Direction vectors: right, down, left, up
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int currentDir = 0;
    
    int row = 0, col = 0;
    struct ListNode* current = head;
    
    while (current) {
        // Fill current position
        matrix[row][col] = current->val;
        current = current->next;
        
        // If no more elements, stop
        if (!current) {
            break;
        }
        
        // Calculate next position in current direction
        int nextRow = row + directions[currentDir][0];
        int nextCol = col + directions[currentDir][1];
        
        // Check if we need to turn (boundary or already filled)
        if (nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || matrix[nextRow][nextCol] != -1) {
            // Turn clockwise
            currentDir = (currentDir + 1) % 4;
            nextRow = row + directions[currentDir][0];
            nextCol = col + directions[currentDir][1];
        }
        
        row = nextRow;
        col = nextCol;
    }
    
    return matrix;
}

// Helper function to create a new node
struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

int main() {
    int m, n;
    scanf("%d", &m);
    scanf("%d", &n);
    
    // Read the rest of the line including the linked list values
    char line[10000];
    
    // Clear any remaining characters in buffer
    int c;
    while ((c = getchar()) != '\n' && c != EOF);
    
    // Read the line with values
    if (fgets(line, sizeof(line), stdin) == NULL) {
        line[0] = '\0';
    }
    line[strcspn(line, "\n")] = '\0';
    
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    
    // Parse the input - handle formats like "3,0,2,6,8" or "[3,0,2,6,8]"
    char* start = line;
    
    // Skip leading whitespace and brackets
    while (*start && (*start == ' ' || *start == '[' || *start == '\t')) {
        start++;
    }
    
    // Remove trailing brackets
    char* end = start + strlen(start) - 1;
    while (end > start && (*end == ' ' || *end == ']' || *end == '\t')) {
        *end = '\0';
        end--;
    }
    
    if (strlen(start) > 0) {
        char* token = strtok(start, ",");
        while (token != NULL) {
            // Skip whitespace in token
            while (*token == ' ') token++;
            
            int val = atoi(token);
            struct ListNode* newNode = createNode(val);
            
            if (head == NULL) {
                head = newNode;
                tail = newNode;
            } else {
                tail->next = newNode;
                tail = newNode;
            }
            
            token = strtok(NULL, ",");
        }
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = spiralMatrix(m, n, head, &returnSize, &returnColumnSizes);
    
    // Output in the expected format
    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");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    // Free linked list
    while (head) {
        struct ListNode* temp = head;
        head = head->next;
        free(temp);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell exactly once, and for each cell we do constant work

✓ Linear Growth

Space Complexity

O(m×n)

Space for the result matrix, plus O(min(m,n,L)) for recursion/iteration where L is linked list length

⚡ 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

Direction Tracking with Boundary Checks — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler