Diagonal Traverse

Diagonal Traverse - Problem

Given an m x n matrix mat, return an array of all the elements of the matrix traversed in diagonal order.

The diagonal traversal follows a zigzag pattern: starting from the top-left corner, move diagonally up-right, then when hitting a boundary, move to the next diagonal and go down-left, alternating this pattern until all elements are visited.

Example: For matrix [[1,2,3],[4,5,6],[7,8,9]], the diagonal order is [1,2,4,7,5,3,6,8,9].

Input & Output

Example 1 — Basic 3x3 Matrix

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]]

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

💡 Note: Start at (0,0)=1, move up-right to (0,1)=2, hit top boundary so switch to down-left: (1,0)=4, hit left boundary so switch to up-right: (2,0)=7, (1,1)=5, (0,2)=3, and so on following the diagonal zigzag pattern.

Example 2 — Rectangular Matrix

$ Input: mat = [[1,2],[3,4]]

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

💡 Note: Start at (0,0)=1, move to (0,1)=2, hit right boundary so move down to (1,0)=3, then to (1,1)=4. The diagonal pattern handles rectangular matrices correctly.

Example 3 — Single Row

$ Input: mat = [[1,2,3,4]]

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

💡 Note: With only one row, we traverse left to right since each element forms its own diagonal.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ m * n ≤ 10⁴
-10⁵ ≤ mat[i][j] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to simulate the diagonal traversal directly by tracking direction and handling boundary conditions. The optimal approach uses direct simulation with O(m×n) time and O(1) space by maintaining current position and direction state while traversing each diagonal path.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force - Diagonal by Diagonal

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

Identify all diagonals by their sum of indices, collect elements from each diagonal, and reverse alternate diagonals to achieve zigzag pattern.

Optimized - Direct Simulation

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

Traverse the matrix directly following diagonal paths, switching direction when hitting boundaries. Track current position and direction to efficiently move through diagonals.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 100005

int graph[MAX_N][20];
int graphSize[MAX_N];
bool visited[MAX_N];
int parent[MAX_N];
bool cycleNodes[MAX_N];

bool dfs(int node, int par, int n) {
    visited[node] = true;
    parent[node] = par;
    
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor == par) continue;
        
        if (visited[neighbor]) {
            int curr = node;
            cycleNodes[neighbor] = true;
            while (curr != neighbor) {
                cycleNodes[curr] = true;
                curr = parent[curr];
            }
            return true;
        } else if (dfs(neighbor, node, n)) {
            return true;
        }
    }
    return false;
}

void findCycle(int n) {
    memset(visited, false, sizeof(visited));
    memset(cycleNodes, false, sizeof(cycleNodes));
    for (int i = 0; i < n; i++) parent[i] = -1;
    
    dfs(0, -1, n);
}

int* solution(int n, int** edges, int edgesSize) {
    // Initialize graph
    memset(graphSize, 0, sizeof(graphSize));
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    findCycle(n);
    
    int* result = (int*)malloc(n * sizeof(int));
    int queue[MAX_N];
    int front = 0, rear = 0;
    
    // Initialize with cycle nodes
    for (int i = 0; i < n; i++) {
        if (cycleNodes[i]) {
            result[i] = 0;
            queue[rear++] = i;
        } else {
            result[i] = -1;
        }
    }
    
    // BFS to find distances
    while (front < rear) {
        int node = queue[front++];
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (result[neighbor] == -1) {  // Not visited
                result[neighbor] = result[node] + 1;
                queue[rear++] = neighbor;
            }
        }
    }
    
    return result;
}

int parseEdges(char* line, int*** edges) {
    int count = 0;
    int capacity = 100;
    *edges = (int**)malloc(capacity * sizeof(int*));
    
    char* ptr = line + 1; // skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int u = 0, v = 0;
            // Parse first number
            while (*ptr >= '0' && *ptr <= '9') {
                u = u * 10 + (*ptr - '0');
                ptr++;
            }
            ptr++; // skip comma
            // Parse second number
            while (*ptr >= '0' && *ptr <= '9') {
                v = v * 10 + (*ptr - '0');
                ptr++;
            }
            
            if (count >= capacity) {
                capacity *= 2;
                *edges = (int**)realloc(*edges, capacity * sizeof(int*));
            }
            (*edges)[count] = (int*)malloc(2 * sizeof(int));
            (*edges)[count][0] = u;
            (*edges)[count][1] = v;
            count++;
            
            while (*ptr && *ptr != '[' && *ptr != ']') ptr++;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    getchar(); // consume newline
    
    char line[200000];
    fgets(line, sizeof(line), stdin);
    
    int** edges;
    int edgesSize = parseEdges(line, &edges);
    
    int* result = solution(n, edges, edgesSize);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    for (int i = 0; i < edgesSize; i++) {
        free(edges[i]);
    }
    free(edges);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

78.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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