HDU 2571 命运 by Assassin

Problem Description
穿过幽谷意味着离大魔王lemon已经无限接近了！
可谁能想到，yifenfei在斩杀了一些虾兵蟹将后，却再次面临命运大迷宫的考验，这是魔王lemon设下的又一个机关。要知道，不论何人，若在迷宫中被困1小时以上，则必死无疑！
可怜的yifenfei为了去救MM，义无返顾地跳进了迷宫。让我们一起帮帮执着的他吧！
命运大迷宫可以看成是一个两维的方格阵列，如下图所示：

yifenfei一开始在左上角，目的当然是到达右下角的大魔王所在地。迷宫的每一个格子都受到幸运女神眷恋或者痛苦魔王的诅咒，所以每个格子都对应一个值，走到那里便自动得到了对应的值。
现在规定yifenfei只能向右或者向下走，向下一次只能走一格。但是如果向右走，则每次可以走一格或者走到该行的列数是当前所在列数倍数的格子，即：如果当前格子是（x,y），下一步可以是（x+1,y），(x,y+1)或者(x,y*k) 其中k>1。
为了能够最大把握的消灭魔王lemon，yifenfei希望能够在这个命运大迷宫中得到最大的幸运值。

Input
输入数据首先是一个整数C，表示测试数据的组数。
每组测试数据的第一行是两个整数n,m，分别表示行数和列数(1<=n<=20,10<=m<=1000)；
接着是n行数据，每行包含m个整数，表示n行m列的格子对应的幸运值K ( |k|<100 )。

Output
请对应每组测试数据输出一个整数，表示yifenfei可以得到的最大幸运值。

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

思路：
其实思路很是简单，就是一般的dp了，我们dp[i][j]表示在第i行第j列的最好情况，那么我们思考，对于(i,j)位置可能的最好值来源时哪里呢？无非就是来自dp[i-1][j]、dp[i][j-1]、和之前某数的倍数，我们这么想每次检索一个位置时用比较一下dp[i-1][j]、dp[i][j-1]、和来自之前某位置的倍数，之前某数的倍数的情况怎么纪录？每次比较万后一个for循环更新一下！（这里需要注意更新时如果当前节点已经被付过值，需要比较，如果没有被赋值，直接赋值即可）
用一个tmp[i][j]纪录该位置是否到达过。（不记录的话可能比较得到最大值，但是时不可能的比如-1，-2，10最后一位应该7而不是10），每次分为tmp[i][j]==1 and ==0两种情况。==0代表之前没有来源，比较时不是dp[i][j]本身，==1时说明之前记录过数据，比较需要加上本身。
但是这就完了吗？NO！注意第一行和第一列！初始化数组的时候dp[i-1][j]和dp[i][j-1]都是0！有数值会干扰第一行（列）的赋值。
下面是代码

#include<bits/stdc++.h>
#define input freopen("input.txt","r",stdin)
using namespace std;
int max3(int a,int b,int c)
{
    if(a>=b&&a>=c)return a;
    if(b>=a&&b>=c)return b;
    if(c>=a&&c>=b)return c;
} 
int value[21][1005];  //数值 
int dp[21][1005];     //dp最优值 
int tmp[21][1005];    //纪录是否该节点被访问过 
int main()
{
    input; 
    int n,m,i,j,k,t;
    while(cin>>t)
    {
        while(t--)
        {
            cin>>n>>m;
            memset(dp,0,sizeof(dp));
            for(i=1;i<=n;i++)
            {
                for(j=1;j<=m;j++)
                {
                    cin>>value[i][j];
                    dp[i][j]=value[i][j];   //这个其实没什么用吧。。。 
                }
            }
            memset(tmp,0,sizeof(tmp));
            for(j=1;j<=m;j++)    //第一行初始化！ 
            {
                if(tmp[1][j])   //如果dp[i][j]已经被访问过，考虑自己纪录的之前的最优值 
                    {
                        dp[1][j]=max(dp[1][j],dp[1][j-1]+value[1][j]);    //不考虑第0行！ 
                    }
                    else
                    {
                        dp[1][j]=dp[1][j-1]+value[1][j];    //直接赋值 
                        tmp[1][j]=1;
                    }
                    for(k=j+j;k<=m;k+=j)     //更新k*j的情况 
                    {
                        if(tmp[1][k])
                        {
                            dp[1][k]=max(dp[1][k],dp[1][j]+value[1][k]);
                        }
                        else
                        {
                            dp[1][k]=dp[1][j]+value[1][k];
                            tmp[1][k]=1;
                        }
                    }
            }
            for(i=1;i<=n;i++)    //更新第一列，只有一条路径从dp[1][1]到dp[n][1] 
            {
                dp[i][1]=dp[i-1][1]+value[i][1];
                tmp[i][1]=1;
            }
            for(i=2;i<=n;i++)    //从第二行第二列跑 
            {
                for(j=1;j<=m;j++)
                {
                    if(tmp[i][j])      //已经被访问过 
                    {
                        dp[i][j]=max3(dp[i][j],dp[i-1][j]+value[i][j],dp[i][j-1]+value[i][j]);
                    }
                    else              //未被访问过 
                    {
                        dp[i][j]=max(dp[i-1][j]+value[i][j],dp[i][j-1]+value[i][j]);
                        tmp[i][j]=1;
                    }
                    for(k=j+j;k<=m;k+=j)
                    {
                        if(tmp[i][k])
                        {
                            dp[i][k]=max(dp[i][k],dp[i][j]+value[i][k]);
                        }
                        else
                        {
                            dp[i][k]=dp[i][j]+value[i][k];
                            tmp[i][k]=1;
                        }
                    }
                }
            }
            cout<<dp[n][m]<<endl;
        }
    }
    return 0;
}

希望大家批评指正