Longest Line of Consecutive One in Matrix

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: 3

💡 Note: The longest line is the vertical line of three 1s in the second column, or the diagonal line in the bottom-right area.

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.

Visualization

Tap to expand

Understanding the Visualization

Set Up Scorekeeping

Create a tracking system for each position and direction

Process Each Position

For each disc, calculate streak length using previous positions

Track Maximum

Keep record of the longest streak found so far

Return Winner

Report the length of the longest consecutive line

Key Takeaway

🎯 Key Insight: Dynamic programming eliminates redundant calculations by building solutions incrementally, tracking the longest line ending at each position rather than starting from each position.

Time & Space Complexity

Time Complexity

⏱️

O(m * n)

We visit each cell once and perform constant work for each direction

✓ Linear Growth

Space Complexity

O(m * n)

We need a 3D DP array of size m × n × 4 to store lengths for each direction

⚡ Linearithmic Space

Constraints

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

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

Approach	Time	Space	Notes
✓ Brute Force (Check All Directions)	O(m * n * max(m, n))	O(1)	Check every cell as a starting point and count consecutive 1s in all four directions
Dynamic Programming (Optimal)	O(m * n)	O(m * n)	Use DP to track the longest line ending at each position in all directions

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>

int countConsecutive(int** mat, int m, int n, int row, int col, int dr, int dc) {
    int count = 0;
    int r = row, c = col;
    
    while (r >= 0 && r < m && c >= 0 && c < n && mat[r][c] == 1) {
        count++;
        r += dr;
        c += dc;
    }
    
    return count;
}

int longestLine(int** mat, int m, int n) {
    if (mat == NULL || m == 0 || n == 0) return 0;
    
    int maxLength = 0;
    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) {
                for (int d = 0; d < 4; d++) {
                    int length = countConsecutive(mat, m, n, i, j, directions[d][0], directions[d][1]);
                    if (length > maxLength) {
                        maxLength = length;
                    }
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    // Parse input and call 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

✓ Linear Space

Constraints

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

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Directions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler