Maximum Trailing Zeros in a Cornered Path

Maximum Trailing Zeros in a Cornered Path - Problem

You are given a 2D integer array grid of size m × n, where each cell contains a positive integer.

A cornered path is a special type of path that can change direction at most once. The path moves exclusively in one direction (horizontal or vertical) until it reaches a turn point, then switches to the perpendicular direction for the remainder of the journey. No cell can be visited twice!

Examples of valid cornered paths:

Pure horizontal: → → → →
Pure vertical: ↓ ↓ ↓
L-shaped: → → → ↓ ↓
Reverse L: ↑ ↑ ← ← ←

Your task is to find the cornered path whose product of all values has the maximum number of trailing zeros. Trailing zeros come from factors of 10, which means we need to count factors of 2 and 5 in the product!

Input & Output

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Paths)	O(m² × n²)	O(1)	Enumerate every possible cornered path and calculate trailing zeros
Prefix Sum Optimization (Optimal)	O(m × n)	O(m × n)	Use prefix sums to count factors of 2 and 5 for instant path evaluation

Brute Force (Try All Paths) — Algorithm Steps

For each cell (i,j) as potential corner point
Try 4 L-shaped patterns: →↓, →↑, ←↓, ←↑, ↓→, ↓←, ↑→, ↑←
Also try pure horizontal and vertical paths
For each valid path, calculate product of all values
Count trailing zeros by dividing by 10 repeatedly
Return maximum trailing zeros found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Corner

Select a cell as potential corner point

Try L-Shapes

Explore all 8 possible L-shaped paths from corner

Calculate Product

Multiply all values along each path

Count Zeros

Count trailing zeros in the product

Code -

solution.c — C

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

int countTrailingZeros(long long num) {
    int count = 0;
    while (num > 0 && num % 10 == 0) {
        count++;
        num /= 10;
    }
    return count;
}

int maxTrailingZeros(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int maxZeros = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Try different L-shaped paths
            int directions[8][2][2] = {
                {{0, 1}, {1, 0}}, {{0, 1}, {-1, 0}},
                {{0, -1}, {1, 0}}, {{0, -1}, {-1, 0}},
                {{1, 0}, {0, 1}}, {{1, 0}, {0, -1}},
                {{-1, 0}, {0, 1}}, {{-1, 0}, {0, -1}}
            };
            
            for (int d = 0; d < 8; d++) {
                int dr1 = directions[d][0][0], dc1 = directions[d][0][1];
                int dr2 = directions[d][1][0], dc2 = directions[d][1][1];
                
                long long product = grid[i][j];
                int r = i, c = j;
                
                // First segment
                while (1) {
                    r += dr1;
                    c += dc1;
                    if (r < 0 || r >= m || c < 0 || c >= n) break;
                    
                    product *= grid[r][c];
                    long long tempProduct = product;
                    int tr = r, tc = c;
                    
                    // Second segment
                    while (1) {
                        tr += dr2;
                        tc += dc2;
                        if (tr < 0 || tr >= m || tc < 0 || tc >= n) break;
                        
                        tempProduct *= grid[tr][tc];
                        int zeros = countTrailingZeros(tempProduct);
                        if (zeros > maxZeros) {
                            maxZeros = zeros;
                        }
                    }
                }
            }
        }
    }
    
    return maxZeros;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n²)

For each of O(mn) corner positions, we potentially explore O(mn) path lengths

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing current path information and maximum result

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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