##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2245.html

# 2245. Maximum Trailing Zeros in a Cornered Path

• Difficulty: Medium.
• Related Topics: Array, Matrix, Prefix Sum.
• Similar Questions: Factorial Trailing Zeroes, Bomb Enemy, Abbreviating the Product of a Range.

## 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.

Example 1: Input: grid = [[23,17,15,3,20],[8,1,20,27,11],[9,4,6,2,21],[40,9,1,10,6],[22,7,4,5,3]]
Output: 3
Explanation: The grid on the left shows a valid cornered path.
It has a product of 15 * 20 * 6 * 1 * 10 = 18000 which has 3 trailing zeros.
It can be shown that this is the maximum trailing zeros in the product of a cornered path.

The grid in the middle is not a cornered path as it has more than one turn.
The grid on the right is not a cornered path as it requires a return to a previously visited cell.


Example 2: Input: grid = [[4,3,2],[7,6,1],[8,8,8]]
Output: 0
Explanation: The grid is shown in the figure above.
There are no cornered paths in the grid that result in a product with a trailing zero.


Constraints:

• m == grid.length

• n == grid[i].length

• 1 <= m, n <= 105

• 1 <= m * n <= 105

• 1 <= grid[i][j] <= 1000

## Solution (Java, C++, Python)

• class Solution {
public int maxTrailingZeros(int[][] grid) {
int m = grid.length;
int n = grid.length;
int max = 0;
int[][] row2 = new int[m + 1][n + 1];
int[][] row5 = new int[m + 1][n + 1];
int[][] col2 = new int[m + 1][n + 1];
int[][] col5 = new int[m + 1][n + 1];
int[][] factor2 = new int[m][n];
int[][] factor5 = new int[m][n];
for (int r = 0; r < m; r++) {
for (int c = 0; c < n; c++) {
int factorTwo = findFactor(grid[r][c], 2);
int factorFive = findFactor(grid[r][c], 5);
row2[r + 1][c + 1] = row2[r + 1][c] + factorTwo;
row5[r + 1][c + 1] = row5[r + 1][c] + factorFive;
col2[r + 1][c + 1] = col2[r][c + 1] + factorTwo;
col5[r + 1][c + 1] = col5[r][c + 1] + factorFive;
factor2[r][c] = factorTwo;
factor5[r][c] = factorFive;
}
}
for (int r = 0; r < m; r++) {
for (int c = 0; c < n; c++) {
int cur2 = factor2[r][c];
int cur5 = factor5[r][c];
int up2 = col2[r + 1][c + 1];
int up5 = col5[r + 1][c + 1];
int down2 = col2[m][c + 1] - col2[r][c + 1];
int down5 = col5[m][c + 1] - col5[r][c + 1];
int left2 = row2[r + 1][c + 1];
int left5 = row5[r + 1][c + 1];
int right2 = row2[r + 1][n] - row2[r + 1][c];
int right5 = row5[r + 1][n] - row5[r + 1][c];
max = Math.max(max, Math.min(left2 + up2 - cur2, left5 + up5 - cur5));
max = Math.max(max, Math.min(right2 + up2 - cur2, right5 + up5 - cur5));
max = Math.max(max, Math.min(left2 + down2 - cur2, left5 + down5 - cur5));
max = Math.max(max, Math.min(right2 + down2 - cur2, right5 + down5 - cur5));
}
}
return max;
}

private int findFactor(int a, int b) {
int factors = 0;
while (a % b == 0) {
a /= b;
factors++;
}
return factors;
}
}

############

class Solution {
public int maxTrailingZeros(int[][] grid) {
int m = grid.length, n = grid.length;
int[][] r2 = new int[m + 1][n + 1];
int[][] c2 = new int[m + 1][n + 1];
int[][] r5 = new int[m + 1][n + 1];
int[][] c5 = new int[m + 1][n + 1];
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
int x = grid[i - 1][j - 1];
int s2 = 0, s5 = 0;
for (; x % 2 == 0; x /= 2) {
++s2;
}
for (; x % 5 == 0; x /= 5) {
++s5;
}
r2[i][j] = r2[i][j - 1] + s2;
c2[i][j] = c2[i - 1][j] + s2;
r5[i][j] = r5[i][j - 1] + s5;
c5[i][j] = c5[i - 1][j] + s5;
}
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
int a = Math.min(r2[i][j] + c2[i - 1][j], r5[i][j] + c5[i - 1][j]);
int b = Math.min(r2[i][j] + c2[m][j] - c2[i][j], r5[i][j] + c5[m][j] - c5[i][j]);
int c = Math.min(r2[i][n] - r2[i][j] + c2[i][j], r5[i][n] - r5[i][j] + c5[i][j]);
int d = Math.min(r2[i][n] - r2[i][j - 1] + c2[m][j] - c2[i][j],
r5[i][n] - r5[i][j - 1] + c5[m][j] - c5[i][j]);
ans = Math.max(ans, Math.max(a, Math.max(b, Math.max(c, d))));
}
}
return ans;
}
}

• class Solution:
def maxTrailingZeros(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid)
r2 = [ * (n + 1) for _ in range(m + 1)]
c2 = [ * (n + 1) for _ in range(m + 1)]
r5 = [ * (n + 1) for _ in range(m + 1)]
c5 = [ * (n + 1) for _ in range(m + 1)]
for i, row in enumerate(grid, 1):
for j, x in enumerate(row, 1):
s2 = s5 = 0
while x % 2 == 0:
x //= 2
s2 += 1
while x % 5 == 0:
x //= 5
s5 += 1
r2[i][j] = r2[i][j - 1] + s2
c2[i][j] = c2[i - 1][j] + s2
r5[i][j] = r5[i][j - 1] + s5
c5[i][j] = c5[i - 1][j] + s5
ans = 0
for i in range(1, m + 1):
for j in range(1, n + 1):
a = min(r2[i][j] + c2[i - 1][j], r5[i][j] + c5[i - 1][j])
b = min(r2[i][j] + c2[m][j] - c2[i][j], r5[i][j] + c5[m][j] - c5[i][j])
c = min(r2[i][n] - r2[i][j] + c2[i][j], r5[i][n] - r5[i][j] + c5[i][j])
d = min(
r2[i][n] - r2[i][j - 1] + c2[m][j] - c2[i][j],
r5[i][n] - r5[i][j - 1] + c5[m][j] - c5[i][j],
)
ans = max(ans, a, b, c, d)
return ans

############

# 2245. Maximum Trailing Zeros in a Cornered Path
# https://leetcode.com/problems/maximum-trailing-zeros-in-a-cornered-path/

class Solution:
def maxTrailingZeros(self, grid: List[List[int]]) -> int:
rows, cols = len(grid), len(grid)

R = []
C = []

def countDivisor(x):
a = b = 0

while x % 2 == 0:
x //= 2
a += 1

while x % 5 == 0:
x //= 5
b += 1

return (a, b)

for x in range(rows):
curr = [(0, 0)]
for y in grid[x]:
a, b = countDivisor(y)
curr.append((curr[-1] + a, curr[-1] + b))

R.append(curr)

for y in range(cols):
curr = [(0, 0)]
for x in range(rows):
a, b = countDivisor(grid[x][y])
curr.append((curr[-1] + a, curr[-1] + b))

C.append(curr)

res = 0

for x in range(rows):
for y in range(cols):
topLeft = min(R[x][y + 1] + C[y][x], R[x][y + 1] + C[y][x])
topRight = min(R[x][-1] - R[x][y] + C[y][x], R[x][-1] - R[x][y] + C[y][x])
botLeft = min(R[x][y] + C[y][-1] - C[y][x], R[x][y] + C[y][-1] - C[y][x])
botRight = min(R[x][-1] - R[x][y + 1] + C[y][-1] - C[y][x], R[x][-1] - R[x][y + 1] + C[y][-1] - C[y][x])
res = max(res, topLeft, topRight, botLeft, botRight)

return res


• class Solution {
public:
int maxTrailingZeros(vector<vector<int>>& grid) {
int m = grid.size(), n = grid.size();
vector<vector<int>> r2(m + 1, vector<int>(n + 1));
vector<vector<int>> c2(m + 1, vector<int>(n + 1));
vector<vector<int>> r5(m + 1, vector<int>(n + 1));
vector<vector<int>> c5(m + 1, vector<int>(n + 1));
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
int x = grid[i - 1][j - 1];
int s2 = 0, s5 = 0;
for (; x % 2 == 0; x /= 2) {
++s2;
}
for (; x % 5 == 0; x /= 5) {
++s5;
}
r2[i][j] = r2[i][j - 1] + s2;
c2[i][j] = c2[i - 1][j] + s2;
r5[i][j] = r5[i][j - 1] + s5;
c5[i][j] = c5[i - 1][j] + s5;
}
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
int a = min(r2[i][j] + c2[i - 1][j], r5[i][j] + c5[i - 1][j]);
int b = min(r2[i][j] + c2[m][j] - c2[i][j], r5[i][j] + c5[m][j] - c5[i][j]);
int c = min(r2[i][n] - r2[i][j] + c2[i][j], r5[i][n] - r5[i][j] + c5[i][j]);
int d = min(r2[i][n] - r2[i][j - 1] + c2[m][j] - c2[i][j], r5[i][n] - r5[i][j - 1] + c5[m][j] - c5[i][j]);
ans = max({ans, a, b, c, d});
}
}
return ans;
}
};

• func maxTrailingZeros(grid [][]int) (ans int) {
m, n := len(grid), len(grid)
r2 := get(m+1, n+1)
c2 := get(m+1, n+1)
r5 := get(m+1, n+1)
c5 := get(m+1, n+1)
for i := 1; i <= m; i++ {
for j := 1; j <= n; j++ {
x := grid[i-1][j-1]
s2, s5 := 0, 0
for ; x%2 == 0; x /= 2 {
s2++
}
for ; x%5 == 0; x /= 5 {
s5++
}
r2[i][j] = r2[i][j-1] + s2
c2[i][j] = c2[i-1][j] + s2
r5[i][j] = r5[i][j-1] + s5
c5[i][j] = c5[i-1][j] + s5
}
}
for i := 1; i <= m; i++ {
for j := 1; j <= n; j++ {
a := min(r2[i][j]+c2[i-1][j], r5[i][j]+c5[i-1][j])
b := min(r2[i][j]+c2[m][j]-c2[i][j], r5[i][j]+c5[m][j]-c5[i][j])
c := min(r2[i][n]-r2[i][j]+c2[i][j], r5[i][n]-r5[i][j]+c5[i][j])
d := min(r2[i][n]-r2[i][j-1]+c2[m][j]-c2[i][j], r5[i][n]-r5[i][j-1]+c5[m][j]-c5[i][j])
ans = max(ans, max(a, max(b, max(c, d))))
}
}
return
}

func get(m, n int) [][]int {
f := make([][]int, m)
for i := range f {
f[i] = make([]int, n)
}
return f
}

func max(a, b int) int {
if a > b {
return a
}
return b
}

func min(a, b int) int {
if a < b {
return a
}
return b
}

• function maxTrailingZeros(grid: number[][]): number {
const m = grid.length;
const n = grid.length;
const r2 = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
const c2 = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
const r5 = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
const c5 = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
for (let i = 1; i <= m; ++i) {
for (let j = 1; j <= n; ++j) {
let x = grid[i - 1][j - 1];
let s2 = 0;
let s5 = 0;
for (; x % 2 == 0; x = Math.floor(x / 2)) {
++s2;
}
for (; x % 5 == 0; x = Math.floor(x / 5)) {
++s5;
}
r2[i][j] = r2[i][j - 1] + s2;
c2[i][j] = c2[i - 1][j] + s2;
r5[i][j] = r5[i][j - 1] + s5;
c5[i][j] = c5[i - 1][j] + s5;
}
}
let ans = 0;
for (let i = 1; i <= m; ++i) {
for (let j = 1; j <= n; ++j) {
const a = Math.min(
r2[i][j] + c2[i - 1][j],
r5[i][j] + c5[i - 1][j],
);
const b = Math.min(
r2[i][j] + c2[m][j] - c2[i][j],
r5[i][j] + c5[m][j] - c5[i][j],
);
const c = Math.min(
r2[i][n] - r2[i][j] + c2[i][j],
r5[i][n] - r5[i][j] + c5[i][j],
);
const d = Math.min(
r2[i][n] - r2[i][j - 1] + c2[m][j] - c2[i][j],
r5[i][n] - r5[i][j - 1] + c5[m][j] - c5[i][j],
);
ans = Math.max(ans, a, b, c, d);
}
}
return ans;
}



Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).