Longest Line of Consecutive One in Matrix - Problem

You're given an m x n binary matrix containing only 0s and 1s. Your task is to find the longest consecutive line of 1s in the matrix.

The line can extend in four different directions:

Horizontal (left to right)
Vertical (top to bottom)
Diagonal (top-left to bottom-right)
Anti-diagonal (top-right to bottom-left)

Return the length of the longest line of consecutive 1s found in any of these directions.

Example: In a matrix with a horizontal line of three 1s and a diagonal line of four 1s, you would return 4.

Input & Output

example_1.py — Basic Matrix

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

› Output: 2

💡 Note: The longest lines are horizontal lines of two 1s in rows 0 and 1, or vertical lines of two 1s in columns 1 and 2.

example_2.py — Single Element

$ Input: mat = [[1,1,1,1]]

› Output: 4

💡 Note: The entire row forms a horizontal line of four consecutive 1s.

example_3.py — Diagonal Pattern

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

› Output: 3

💡 Note: The main diagonal from top-left to bottom-right contains three consecutive 1s.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ m * n ≤ 10⁴
mat[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses dynamic programming to track the longest consecutive line ending at each position in all four directions. This approach achieves O(m × n) time complexity by avoiding redundant calculations, making it significantly more efficient than the brute force approach.

Common Approaches

✓ Brute Force (Check All Directions)

⏱️ Time: O(m * n * max(m, n)) Space: O(1)

For each cell containing a 1, we start counting consecutive 1s in all four directions (horizontal, vertical, diagonal, anti-diagonal). This approach is straightforward but inefficient as we recompute overlapping sequences multiple times.

Dynamic Programming (Optimal)

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

Instead of recalculating from every position, we use dynamic programming to build up the solution. For each cell, we maintain the length of the longest line ending at that cell in each of the four directions. This eliminates redundant calculations and achieves optimal time complexity.

Brute Force (Check All Directions) — Algorithm Steps

Iterate through each cell in the matrix
For each cell with value 1, check all four directions
Count consecutive 1s in each direction from that starting point
Keep track of the maximum length found across all directions and starting points

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Starting Cell

Choose a cell with value 1 as starting point

Check Horizontal

Count consecutive 1s moving right

Check Vertical

Count consecutive 1s moving down

Check Diagonal

Count consecutive 1s moving diagonally down-right

Check Anti-diagonal

Count consecutive 1s moving diagonally down-left

Code -

solution.c — C

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

static int mat[100][100];
static int m, n;

int solution() {
    if (m == 0 || n == 0) {
        return 0;
    }
    
    int maxLen = 0;
    
    // Four directions: horizontal, vertical, diagonal, anti-diagonal
    int directions[4][2] = {{0, 1}, {1, 0}, {1, 1}, {1, -1}};
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j] == 1) {
                // Check each direction from this position
                for (int d = 0; d < 4; d++) {
                    int length = 1;
                    int ni = i + directions[d][0], nj = j + directions[d][1];
                    
                    // Count consecutive 1s in this direction
                    while (ni >= 0 && ni < m && nj >= 0 && nj < n && mat[ni][nj] == 1) {
                        length++;
                        ni += directions[d][0];
                        nj += directions[d][1];
                    }
                    
                    if (length > maxLen) {
                        maxLen = length;
                    }
                }
            }
        }
    }
    
    return maxLen;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D matrix from JSON format
    m = 0; n = 0;
    
    char* p = line;
    while (*p && *p != '[') p++; // Find first [
    if (*p == '[') p++; // Skip outer [
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n') p++;
        if (*p == ']') break;
        
        if (*p == '[') {
            p++; // Skip row [
            int col = 0;
            
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']') break;
                
                mat[m][col] = (int)strtol(p, &p, 10);
                col++;
            }
            
            if (m == 0) n = col; // Set number of columns from first row
            m++;
            
            if (*p == ']') p++; // Skip row ]
        }
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * max(m, n))

For each of the m*n cells, we potentially scan up to max(m,n) cells in each direction

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum lengths

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Longest Line of Consecutive One in Matrix - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Directions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler