动态规划

题意：求从左上角走到右下角所经过的路径上的数字之积末尾含有最少的0

dp求出从左上角到右下角所经过的路径所含2,5最少的路径,同时检测所给数组中是否含有0,输出答案。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <string.h>
#include <string>

using namespace std;

const int MAXN = 1000 + 38;
const int inf = 1000000000;

int mt[MAXN][MAXN][2];
int dp[MAXN][MAXN][2];
int path[MAXN][MAXN][2];
int temp[MAXN][MAXN];

int cal2(int x)
{
    int res = 0;

    while (x % 2 == 0)
    {
        res++;
        x /= 2;
    }

    return res;
}

int cal5(int x)
{
    int res = 0;

    while (x % 5 == 0)
    {
        res++;
        x /= 5;
    }

    return res;
}

void dfs(int x, int y, int k)
{
    if (x == 1 && y == 1) return ;
    if (x < 1 || y < 1) return ;
    if (path[x][y][k])
    {
        dfs(x - 1, y, k);
        printf("D");
    }
    else
    {
        dfs(x, y - 1, k);
        printf("R");
    }
}

void input()
{
    int n;

    while (scanf("%d", &n) != EOF)
    {
        int flag = 0;

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                scanf("%d", &temp[i][j]);
                if (temp[i][j] == 0)
                {
                    flag = i;
                    continue;
                }
                mt[i][j][0] = cal2(temp[i][j]);
                mt[i][j][1] = cal5(temp[i][j]);
            }
        }

        for (int i = 0; i <= n; i++)
        {
            for (int j = 0; j <= n; j++)
            {
                dp[i][j][0] = dp[i][j][1] = inf;    //无穷大,因为dp求小值
            }
        }

        dp[1][1][0] = mt[1][1][0], dp[1][1][1] = mt[1][1][1];    //初始化

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (temp[i][j] == 0) continue;
                if (i == 1 && j == 1) continue;

                if (dp[i - 1][j][0] < dp[i][j - 1][0] && i > 1)
                {
                    dp[i][j][0] = dp[i - 1][j][0] + mt[i][j][0];
                    path[i][j][0] = 1;
                }
                else
                {
                    dp[i][j][0] = dp[i][j - 1][0] + mt[i][j][0];
                    path[i][j][0] = 0;
                }

                if (dp[i - 1][j][1] < dp[i][j - 1][1] && i > 1)
                {
                    dp[i][j][1] = dp[i - 1][j][1] + mt[i][j][1];
                    path[i][j][1] = 1;
                }
                else
                {
                    dp[i][j][1] = dp[i][j - 1][1] + mt[i][j][1];
                    path[i][j][1] = 0;
                }

                //cout << dp[i][j][1] << ' ';
            }
            //cout << endl;
        }

        int ans = min(dp[n][n][0], dp[n][n][1]);
        int k = dp[n][n][0] < dp[n][n][1] ? 0 : 1;

        if (ans > 1 && flag)
        {
            printf("1\n");

            for (int i = 1; i < flag; i++)
            {
                printf("D");
            }

            for (int i = 1; i < n; i++)
            {
                printf("R");
            }

            for (int i = flag; i < n; i++)
            {
                printf("D");
            }
            printf("\n");
        }
        else
        {
            printf("%d\n", ans);
            dfs(n, n, k);
            printf("\n");
        }
    }
}

int main()
{
    input();
    return 0;
}