Length of Longest V-Shaped Diagonal Segment

Length of Longest V-Shaped Diagonal Segment - Problem

You're navigating through a mystical grid where each cell contains either a 0 (empty space), 1 (starting point), or 2 (energy boost). Your goal is to find the longest possible V-shaped diagonal journey.

What makes a valid V-shaped diagonal segment?

🚀 Start: Must begin with a cell containing 1
🔄 Pattern: After the starting 1, follow the infinite sequence: 2, 0, 2, 0, 2, 0...
↗️ Direction: Move diagonally (NE, NW, SE, or SW)
🔀 Turn: You can make at most one 90-degree clockwise turn to change diagonal direction

Think of it like drawing a "V" or "L" shape on the grid while collecting the right sequence of numbers!

Example: A path might go NE for 3 steps following 1→2→0→2, then turn clockwise to SE and continue →0→2→0 for a total length of 7.

Return the length of the longest valid V-shaped diagonal segment, or 0 if none exists.

Input & Output

example_1.py — Basic V-Shape

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

› Output: 4

💡 Note: Starting at (0,0) with value 1, we can go SE to (1,1) with value 2, then SE to (2,2) with value 2 (but we expect 0, so this doesn't work). Starting at (1,2) with value 1, we can go SW to (2,1) with value 0, then SW to out of bounds. The optimal path starts at (0,0): 1→2→0→2 going NE then turning to SE, giving length 4.

example_2.py — Straight Line

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

› Output: 5

💡 Note: A straight diagonal line starting with 1 and following the sequence 2,0,2,0... The path goes: (0,0)→(0,1)→(0,2)→(0,3)→(0,4) but since we need diagonal movement, this example would be modified to a diagonal case. For a proper diagonal: 1 at (0,0), 2 at (1,1), 0 at (2,2), 2 at (3,3), 0 at (4,4) would give length 5.

example_3.py — No Valid Path

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

› Output: 1

💡 Note: There are starting points with value 1 at (1,0) and (2,1), but no valid continuation following the required sequence in diagonal directions. Each starting point contributes length 1 but cannot extend further, so maximum is 1.

Constraints

1 ≤ n, m ≤ 100
grid[i][j] ∈ {0, 1, 2}
At least one cell contains value 1 (guaranteed starting point)
Diagonal directions only: NE, SE, SW, NW movements
At most one turn: Can change direction clockwise once

Visualization

Tap to expand

Understanding the Visualization

Find Starting Crystals

Locate all cells containing '1' - these are your possible starting points

Choose Direction

From each start, pick one of 4 diagonal directions: NE, SE, SW, NW

Follow the Pattern

Move diagonally following the sequence: 1→2→0→2→0→2→0...

Strategic Turn

At any point, you can make one clockwise 90° turn to a new diagonal direction

Maximize Length

Continue until pattern breaks or bounds reached, tracking maximum length

Key Takeaway

🎯 Key Insight: By using memoization to cache the maximum length achievable from each state (position + direction + expected value + turn status), we transform an exponential brute force algorithm into an efficient polynomial solution.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 31 Apple 18

The optimal approach uses dynamic programming with memoization to avoid redundant calculations. We explore all possible diagonal paths starting from cells containing '1', following the sequence 1→2→0→2→0..., while allowing at most one clockwise turn. The key insight is caching results for each state (position, direction, expected value, turn status) to achieve O(n×m×4×3×2) time complexity instead of exponential brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Paths)	O(n × m × 4^k)	O(k)	Check every cell as starting point and explore all possible diagonal paths with turns
Dynamic Programming with Memoization (Optimal)	O(n × m × 4 × 3 × 2)	O(n × m × 4 × 3 × 2)	Use memoization to cache results for each position and state, avoiding redundant calculations

Brute Force (Try All Paths) — Algorithm Steps

Iterate through every cell in the grid
For each cell containing '1', start a new path exploration
For each starting position, try all 4 diagonal directions
Use DFS to follow the path, checking sequence: 2,0,2,0...
At each position, try continuing straight or making one clockwise turn
Track the maximum length found across all explorations

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Starting Points

Locate all cells containing '1' as potential starting positions

Try All Directions

From each start, explore NE, SE, SW, NW diagonal directions

Follow Sequence

Check if path follows 1→2→0→2→0... pattern

Consider Turns

At each step, try continuing straight or making one clockwise turn

Track Maximum

Keep track of the longest valid path found

Code -

solution.c — C

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

int n, m, maxLength;
int directions[4][2] = {{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};

void dfs(int** grid, int row, int col, int direction, int length, int expectedVal, int hasTurned) {
    if (row < 0 || row >= n || col < 0 || col >= m) return;
    if (grid[row][col] != expectedVal) return;
    
    if (length > maxLength) maxLength = length;
    
    int nextVal = (expectedVal == 1) ? 2 : ((expectedVal == 2) ? 0 : 2);
    int newRow = row + directions[direction][0];
    int newCol = col + directions[direction][1];
    
    dfs(grid, newRow, newCol, direction, length + 1, nextVal, hasTurned);
    
    if (!hasTurned) {
        int newDirection = (direction + 1) % 4;
        int turnRow = row + directions[newDirection][0];
        int turnCol = col + directions[newDirection][1];
        dfs(grid, turnRow, turnCol, newDirection, length + 1, nextVal, 1);
    }
}

int longestVShapedDiagonal(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0) return 0;
    
    n = gridSize;
    m = gridColSize[0];
    maxLength = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) {
                for (int dir = 0; dir < 4; dir++) {
                    dfs(grid, i, j, dir, 1, 1, 0);
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    printf("V-Shaped Diagonal Solver Ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × 4^k)

For each of n×m cells, we might explore paths of length k in 4 directions with potential turns

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth proportional to maximum path length k

✓ Linear Space

52.0K Views

Medium-High Frequency

~35 min Avg. Time

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

Brute Force (Try All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler