Length of Longest V-Shaped Diagonal Segment - Problem

You are given a 2D integer matrix grid of size n x m, where each element is either 0, 1, or 2.

A V-shaped diagonal segment is defined as:

The segment starts with 1
The subsequent elements follow this infinite sequence: 2, 0, 2, 0, ...
The segment starts along a diagonal direction (top-left to bottom-right, bottom-right to top-left, top-right to bottom-left, or bottom-left to top-right)
Continues the sequence in the same diagonal direction
Makes at most one clockwise 90-degree turn to another diagonal direction while maintaining the sequence

Return the length of the longest V-shaped diagonal segment. If no valid segment exists, return 0.

Input & Output

Example 1 — Basic V-Shape

$ Input: grid = [[1,2,0],[0,2,0],[1,0,2]]

› Output: 1

💡 Note: Starting at (0,0) with value 1, no valid continuation exists following the sequence 1→2→0→2→0... The grid at (1,1) has value 2 but position 2 in sequence expects 0.

Example 2 — No Valid Segment

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

› Output: 1

💡 Note: Only single cells with value 1 can form segments of length 1, as the sequence 2,0,2,0... cannot be followed.

Example 3 — V-Shape with Turn

$ Input: grid = [[1,0,0],[2,0,0],[0,2,0]]

› Output: 1

💡 Note: Start at (0,0) with value 1. Going down to (1,0) gives value 2, but this is not a diagonal direction. Following diagonal directions, no valid sequence of length > 1 exists.

Constraints

1 ≤ n, m ≤ 1000
grid[i][j] ∈ {0, 1, 2}
At least one element in the grid

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that a V-shaped diagonal segment follows a specific pattern (1→2→0→2→0...) and can make at most one clockwise 90-degree turn. The optimal approach uses DFS with memoization to explore all possible paths while caching results to avoid redundant calculations. Time: O(nm × 4 × L × 2), Space: O(nm × 4 × L × 2).

Common Approaches

✓ Dp 2d

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

Brute Force DFS

⏱️ Time: O(n²m²) Space: O(nm)

For each cell containing '1', start a depth-first search in all four diagonal directions. For each direction, follow the pattern 1→2→0→2→0... and optionally make one clockwise turn to continue the sequence.

Memoization with DFS

⏱️ Time: O(nm × 4 × L × 2) Space: O(nm × 4 × L × 2)

Use memoization to store the results of DFS calls with specific states (position, direction, turn status). This prevents recalculating the same subproblems multiple times.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_MEMO 100000

typedef struct {
    int left, right;
    char prevChar, nextChar;
    int result;
} MemoEntry;

MemoEntry memoTable[MAX_MEMO];
int memoCount = 0;

int findMemo(int left, int right, char prevChar, char nextChar) {
    for (int k = 0; k < memoCount; k++) {
        if (memoTable[k].left == left && memoTable[k].right == right && 
            memoTable[k].prevChar == prevChar && memoTable[k].nextChar == nextChar) {
            return memoTable[k].result;
        }
    }
    return -1;
}

void addMemo(int left, int right, char prevChar, char nextChar, int result) {
    if (memoCount < MAX_MEMO) {
        memoTable[memoCount].left = left;
        memoTable[memoCount].right = right;
        memoTable[memoCount].prevChar = prevChar;
        memoTable[memoCount].nextChar = nextChar;
        memoTable[memoCount].result = result;
        memoCount++;
    }
}

int max(int a, int b) {
    return a > b ? a : b;
}

int dp(const char* s, int left, int right, char prevChar, char nextChar) {
    if (left > right) return 0;
    
    int cached = findMemo(left, right, prevChar, nextChar);
    if (cached != -1) return cached;
    
    int result = 0;
    
    // Try not including left character
    result = max(result, dp(s, left + 1, right, prevChar, nextChar));
    
    // Try not including right character
    result = max(result, dp(s, left, right - 1, prevChar, nextChar));
    
    // Try including both left and right if they match
    if (s[left] == s[right] && left < right) {
        int canPlace = 1;
        
        // Check if left character conflicts with previous
        if (prevChar != '\0' && prevChar == s[left]) {
            canPlace = 0;
        }
        
        // Check if right character conflicts with next
        if (nextChar != '\0' && nextChar == s[right]) {
            canPlace = 0;
        }
        
        if (canPlace) {
            result = max(result, 2 + dp(s, left + 1, right - 1, s[left], s[right]));
        }
    }
    
    addMemo(left, right, prevChar, nextChar, result);
    return result;
}

int solution(const char* s) {
    memoCount = 0;
    return dp(s, 0, strlen(s) - 1, '\0', '\0');
}

int main() {
    char s[MAX_N];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

240 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

Length of Longest V-Shaped Diagonal Segment - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler