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 x n, where each cell contains a positive integer.

A cornered path is defined as a set of adjacent cells with at most one turn. More specifically, the path should exclusively move either horizontally or vertically up to the turn (if there is one), without returning to a previously visited cell. After the turn, the path will then move exclusively in the alternate direction: move vertically if it moved horizontally, and vice versa, also without returning to a previously visited cell.

The product of a path is defined as the product of all the values in the path.

Return the maximum number of trailing zeros in the product of a cornered path found in grid.

Note:

Horizontal movement means moving in either the left or right direction.
Vertical movement means moving in either the up or down direction.

Input & Output

Example 1 — Basic 3×3 Grid

$ Input: grid = [[23,17,15],[3,5,14],[9,6,1]]

› Output: 3

💡 Note: The path (1,0)→(1,1)→(1,2)→(2,2) gives product 3×5×14×1 = 210. Since 210 = 2¹×3×5¹×7, it has min(1,1) = 1 trailing zero. However, the path (2,0)→(2,1)→(1,1)→(0,1) gives 9×6×5×17 = 4590 = 2¹×3²×5¹×17, which has 1 trailing zero. The optimal path yields 3 trailing zeros.

Example 2 — Single Row

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

› Output: 1

💡 Note: Path covers all cells: 1×5×2 = 10 = 2¹×5¹, giving min(1,1) = 1 trailing zero.

Example 3 — Powers of 10

$ Input: grid = [[10,100],[1000,1]]

› Output: 5

💡 Note: Path (0,0)→(0,1)→(1,1) gives 10×100×1 = 1000 = 2³×5³, so min(3,3) = 3 trailing zeros. Path (1,0)→(0,0)→(0,1) gives 1000×10×100 = 10⁶, which has 6 trailing zeros, but optimal L-shaped path gives 5.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m × n ≤ 10⁵
1 ≤ grid[i][j] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 f Meta 6

The key insight is that trailing zeros come from factors of 10 = 2×5. Instead of calculating huge products, count factors of 2 and 5 separately using prefix sums for efficient range queries. For each possible cornered path, the trailing zeros equals min(total 2s, total 5s). Best approach: Prefix Sum - Time: O(m²n²), Space: O(mn)

Common Approaches

✓ Brute Force - Check All Paths

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

For each cell as a corner point, explore all possible L-shaped paths (horizontal then vertical, and vertical then horizontal). Calculate the product and count trailing zeros.

Prefix Sum Optimization

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

Instead of calculating products directly, count factors of 2 and 5 separately using prefix sums. Trailing zeros equal min(factors of 2, factors of 5) in the path.

Brute Force - Check All Paths — Algorithm Steps

Iterate through each cell as potential corner
Generate all horizontal-then-vertical paths
Generate all vertical-then-horizontal paths
Calculate product and count trailing zeros for each path

Visualization

Tap to expand

Step-by-Step Walkthrough

Corner Selection

Try each cell as corner point

Path Generation

Create horizontal-then-vertical and vertical-then-horizontal paths

Product Calculation

Calculate product and count trailing zeros

Code -

solution.c — C

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

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

int getProductZeros(int* path, int len) {
    long long product = 1;
    for (int i = 0; i < len; i++) {
        product *= path[i];
    }
    return countTrailingZeros(product);
}

int solution(int** grid, int m, int n) {
    int maxZeros = 0;
    int path[1000]; // Assuming max path length
    
    // Try all possible cornered paths
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Horizontal then vertical paths
            for (int left = 0; left <= j; left++) {
                for (int right = j; right < n; right++) {
                    for (int up = 0; up <= i; up++) {
                        for (int down = i; down < m; down++) {
                            int pathLen = 0;
                            // Horizontal part
                            for (int c = left; c <= right; c++) {
                                path[pathLen++] = grid[i][c];
                            }
                            // Vertical part (excluding corner)
                            for (int r = up; r <= down; r++) {
                                if (r != i) {
                                    path[pathLen++] = grid[r][j];
                                }
                            }
                            if (pathLen > 0) {
                                int zeros = getProductZeros(path, pathLen);
                                if (zeros > maxZeros) {
                                    maxZeros = zeros;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    return maxZeros;
}

int main() {
    // Simple parsing for demo
    int grid[3][3] = {{23, 17, 15}, {3, 5, 14}, {9, 6, 1}};
    int* gridRows[3] = {grid[0], grid[1], grid[2]};
    
    int result = solution(gridRows, 3, 3);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each cell, we explore paths in 4 directions, each potentially of length m or n

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track current path and maximum

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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 - Check All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler