CF2B The least round way

题目链接

sample:
input：
3
1 2 3
4 5 6
7 8 9
output：
0
DDRR

分析：题目没有说是输入范围在1 — n * n 的数，数的范围是到0 —10⁹ 。所以，就算找到一条合适的路径，直接把路径上的数相乘，判断末尾0的个数，这种方法是绝对行不通的。
我们知道，只有是2的倍数和5的倍数相乘，才可以出现末尾0，所以我们计算答案的末尾0的个数，就是看这个数中有多少对<2，5>，并让其最小。众所周知，当其中一个数的数量最小的时候，另外一个数的数量不管多大都不会影响答案。
即 ans = min(num2，num5)。
其中还有一个情况很特殊，如果一条路径上有0，那么结果也一定是0，就只有一个末尾0。如果ans > 1，并且矩阵中有0，所以找一条经过0的路径就好。
代码中有简单注释，可以帮助理解

code：

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 1e3 + 100;
const int INF = 0x3f3f3f3f;

int a[N][N];
/*第三维记录是2还是5的个数*/
int p[N][N][5];
int dp[N][N][5];
stack<char> st;

void Pri(int x, int y, int k) {
    if (x == 1 && y == 1) {//回到起点
        return;
    }
    //同样的，当x=1的时候，只能从左边走过来
    //当y=1的时候，只能从上边走过来
    if (x == 1) {
        st.push('R');
        Pri(x, y - 1, k);
        return;
    } else if (y == 1) {
        st.push('D');
        Pri(x - 1, y, k);
        return;
    }
    //这就是看是在左边走过来的还是在上边走过来的
    if (dp[x - 1][y][k] + p[x][y][k] == dp[x][y][k]) {
        st.push('D');
        Pri(x - 1, y, k);
    } else if (dp[x][y - 1][k] + p[x][y][k] == dp[x][y][k]) {
        st.push('R');
        Pri(x, y - 1, k);
    }
}

int main(int argc, char const *argv[]) {
    int n;
    int flag = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    int xx = 0, yy = 0;
    /*首先预处理出来每个数中2和5的个数*/
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            int x = a[i][j];
            if (x == 0) {
                flag = 1;
                xx = i, yy = j;
                continue;  //不要忘记加上，不然后边就死循环，因为0 % 2 == 0
            }
            while (x % 2 == 0) {
                p[i][j][1]++;
                x = x / 2;
            }
            while (x % 5 == 0) {
                p[i][j][2]++;
                x = x / 5;
            }
        }
    }

    for (int k = 1; k <= 2; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1) {  //当i=1的时候，只能从左边走过来
                    dp[i][j][k] = dp[i][j - 1][k] + p[i][j][k];
                } else if (j == 1) {  //当j=1的时候，只能从上边走过来
                    dp[i][j][k] = dp[i - 1][j][k] + p[i][j][k];
                } else {
                    dp[i][j][k] =
                        min(dp[i - 1][j][k], dp[i][j - 1][k]) + p[i][j][k];
                }
            }
        }
    }

    int ans = min(dp[n][n][1], dp[n][n][2]);

    if (ans > 1 && flag) {  //这就是那种特殊情况
        //什么路径无所谓，只要经过(xx,yy)就可以
        printf("1\n");
        for (int i = 1; i < xx; i++) {
            printf("D");
        }
        for (int i = 1; i < yy; i++) {
            printf("R");
        }
        for (int i = xx; i < n; i++) {
            printf("D");
        }
        for (int i = yy; i < n; i++) {
            printf("R");
        }
    } else {
        printf("%d\n", ans);
        //判断是找2的最小个数的路径还是5的最小个数的路径
        //递归找出路径，用栈记录
        if (dp[n][n][1] < dp[n][n][2]) {
            Pri(n, n, 1);
        } else {
            Pri(n, n, 2);
        }
        //输出答案
        while (!st.empty()) {
            printf("%c", st.top());
            st.pop();
        }
        printf("\n");
    }
    return 0;
}