2017年第0届浙江工业大学之江学院程序设计竞赛决赛—B

Problem B: qwb与矩阵

Time Limit: 2 Sec  Memory Limit: 128 MB
Submit: 1189  Solved: 250

[Submit][Status][Web
Board]

Description

做完了辣么多的数学题，qwb好好睡了一觉。但是他做了一个梦：

有一个n*m的矩阵，qwb在这个矩阵的左上角(1,1)，终点在右下角(n,m)。
每个格子中有小钱钱，也可能没有，还有可能是要交过路费的，并且行走方向必须是靠近终点的方向。
往下走一次只能走一格，往右走一次可以走
4000
一格也可以走到当前列数的倍数格。 
比如当前格子是（x,y），那么可以移动到(x+1,y),(x,y+1)或者(x,y*k),其中k>1。

qwb希望找到一种走法，使得到达右下角时他能够有最多的小钱钱。

你能帮助他吗？

Input

第一行是测试例数量 T （T<=100），接下来是T组测试数据。
每组测试数据的第一行是两个整数n,m，分别表示行数和列数(1<=n<=20,1<=m<=10000)； 
接下去给你一个n*m的矩阵，每个格子里有一个数字 k （-100<=k<=100）代表小钱钱的数量。 ∑nm<=3,000,000 

Output

每组数据一行，输出L先生能够获得小钱钱的最大值(可能为负数)。

Sample Input

1
3 8
9 10 10 10 10 -10 10 10
10 -11 -1 0 2 11 10 -20
-11 -11 10 11 2 10 -10 -10

Sample Output

52

HINT

想法一：
记忆化搜索
代码：

#include<stdio.h>

#include<string.h>

#define INF 0x3f3f3f3f

int a[25][10100];

int dp[25][10100];

int vis[25][10100];

int n,m;

int max(int x,int y)

{

    return x>y?x:y;

}

bool check(int x,int y)//判断边界

{

    return (x>=1&&x<=n&&y>=1&&y<=m);

}

int dfs(int x,int y)

{

    if(vis[x][y])

        return dp[x][y];

    else

    {

        vis[x][y]=1;

        int t=-INF;

        if(check(x+1,y))//移动到(x+1,y)

            t=max(t,dfs(x+1,y));

        if(check(x,y+1))//移动到(x,y+1)

            t=max(t,dfs(x,y+1));

        for (int k=2;y*k<=m;k++)//移动到(x,y*k)

            if(check(x,y*k))

                t=max(t,dfs(x,y*k));

        if(t==-INF)

            t=0;

        return dp[x][y]=t+a[x][y];

    }

}

int main(void)

{

    int pp;

    scanf("%d",&pp);

    while (pp--)

    {

        memset(vis,0,sizeof(vis));

        memset(dp,0,sizeof(dp));

        scanf("%d%d",&n,&m);

        for (int i=1;i<=n;i++)

            for (int j=1;j<=m;j++)

                scanf("%d",&a[i][j]);

        dfs(1,1);

        printf("%d\n",dp[1][1]);

    }

    return 0;

}

想法二：
动态规划
代码一（C语言）：

#include<stdio.h>

#include<string.h>

#include<math.h>

#define inf 0x3f3f3f3f

int t, n, m, x, dp[25][10005];

int cs[10005][350];

int tt[10005];

int max(int a,int b)

{

    return a>b?a:b;

}

void init()

{

    //预处理出前10000个数的除数

    for(int i = 1; i <= 10000; ++i)

    {

        tt[i] = 0;

        for(int j = 2, p = sqrt(i); j <= p; ++j)

        {

            if(i%j == 0)

            {

                cs[i][tt[i]] = j;

                tt[i]++;

            }

        }

    }

}

int main()

{

    init();

    scanf("%d", &t);

    while(t--)

    {

        scanf("%d %d", &n, &m);

        for(int i = 1; i <= n; ++i)

            for(int j = 1; j <= m; ++j)

            {

                dp[i][j] = -inf;

                scanf("%d", &x);

                if(i == 1 && j == 1)

                    dp[i][j] = x;

                if(i > 1)

                    dp[i][j] = max(dp[i][j], dp[i-1][j]+x);

                if(j > 1)

                    dp[i][j] = max(dp[i][j], dp[i][j-1]+x);

                //如果j不为1，所以可通过dp[i][1]达到dp[i][j]

                if(j > 1)

                    dp[i][j] = max(dp[i][j], dp[i][1]+x);

                for(int k = 0; k < tt[j]; ++k)

                {

                    dp[i][j] = max(dp[i][j], dp[i][j/cs[j][k]]+x);

                    dp[i][j] = max(dp[i][j], dp[i][cs[j][k]]+x);

                }

            }

        printf("%d\n", dp
[m]);

    }

    return 0;

}

代码二（c++）：
#include<stdio.h>

#include<string.h>

#include<algorithm>

#include<vector>

using namespace std;

int dp[22][10010];

int map[22][10010];

vector<int>v[10010];

int main()

{

    int T;

    scanf("%d",&T);

    for(int i=1;i<10010;i++)

    for(int j=i*2;j<10010;j+=i)

    v[j].push_back(i);

    while(T--)

    {

        int n,m;

        scanf("%d%d",&n,&m);

        for(int i=1;i<=n;i++)

        {

            for(int j=1;j<=m;j++)

            {

                scanf("%d",&map[i][j]);

            }

        }

        for(int i=0;i<=n;i++)

        for(int j=0;j<=m;j++)

        dp[i][j]=-1e9;

        dp[1][1]=map[1][1];

        for(int i=1;i<=n;i++)

        {

            for(int j=1;j<=m;j++)

            {

                dp[i][j]=max(dp[i][j],max(dp[i][j-1],dp[i-1][j])+map[i][j]);

                for(int k=0;k<v[j].size();k++)

                {

                    dp[i][j]=max(dp[i][j],dp[i][v[j][k]]+map[i][j]);

                }

            }

        }

        printf("%d\n",dp
[m]);

    }

}