hihoCoder #1241 Best Route in a Grid

Description

Given an n*n grid with non-negative integers, you start from the upper left corner (1,1) and can only move right or down.

Your task is to find the best route to the lower right corner (n,n) without reaching the grid marked with 0.

The best route is when you multiply all the integers you reach on the route, the number of trailing zeros of the product is minimized.

Input

First line with an integer n.

Then n lines, each line with n integers. The numbers in the grid are <= 1,000,000.

The data guarantee that there is at least one legal route.

Output

One line with an integer indicating the answer.

Sample Input

4
1 3 0 0
0 8 2 25
6 5 0 3
0 15 7 4

Sample Output

2

Solution

#include <cstdlib>
#include <cstdio>
#include <vector>
#include <climits>
using namespace std;
#define min(a, b) (a<b?a:b)
#define INF 0x3f3f3f3f

int get2(int a) {
    int cnt = 0;
    while (a % 2 == 0) {
        cnt++;
        a >>= 1;
    }
    return cnt;
}


int get5(int a) {
    int cnt = 0; 
    while (a % 5 == 0) {
        cnt++;
        a /= 5;
    }
    return cnt;
}

void calc(vector<vector<int> > &grid, vector<vector<int> > &cc2, vector<vector<int> > &cc5) {
    int N = grid.size();
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (grid[i][j]) {
                cc2[i][j] = get2(grid[i][j]);
                cc5[i][j] = get5(grid[i][j]);
            }
            else {
                cc2[i][j] = INF;
                cc5[i][j] = INF;
            }
        }
    }
}

int main() {
    int N;
    scanf("%d", &N);
    vector<vector<int> > grid(N, vector<int>(N, 0));
    vector<vector<int> > cc2(N, vector<int>(N, 0));
    vector<vector<int> > cc5(N, vector<int>(N, 0));
    vector<vector<int> > dp2(N+1, vector<int>(N+1, INF));
    vector<vector<int> > dp5(N + 1, vector<int>(N + 1, INF));
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            int v;
            scanf("%d", &v);
            grid[i][j] = v;            
        }    
    }
    calc(grid, cc2, cc5);
    dp2[1][1] = cc2[0][0];
    for (int i = 1; i <= N; ++i) {
        for (int j = 1; j <= N; ++j) {
            dp2[i][j] = min(dp2[i][j], min(dp2[i - 1][j], dp2[i][j - 1]) + cc2[i-1][j-1]);
        }
    }

    int ans = dp2[N][N];

    dp5[1][1] = cc5[0][0];
    for (int i = 1; i <= N; ++i) {
        for (int j = 1; j <= N; ++j) {
            dp5[i][j] = min(dp5[i][j], min(dp5[i - 1][j], dp5[i][j - 1]) + cc5[i - 1][j - 1]);
        }
    }

    ans = min(dp2[N][N], dp5[N][N]);

    printf("%d\n", ans);
}