51Nod 1084 矩阵取数问题 V2（多线程dp）

原题地址：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1084

思路：

 方法一：dp暴力

      首先想到的方法是先找出最大的一条路，将路上的节点值赋为0，再用dp求一次最大值。再一想这肯定不对，这样先后走时的最优解不一定是同时走时的最优解。

      换个思路，要求两条路同时走的最大值，只能让两条路一起dp，用dp[i][j][k][w]来表示同时从（1,1）分别走到（i，j）和（k，w）的路的和的最大值，题解就是dp[n][m][n][m]，算法时间复杂度为O(n*n*m*m)。

代码如下：

#include<stdio.h>
#include<cstring>
using namespace std;
#define max(a,b) a>b?a:b
const int maxn=100;
int mapp[maxn][maxn];
int dp[maxn][maxn][maxn][maxn];
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&mapp[i][j]);
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int k=1;k<=n;k++){
                for(int w=1;w<=m;w++){
                    dp[i][j][k][w]=dp[i-1][j][k-1][w];
                    dp[i][j][k][w]=max(dp[i][j][k][w],dp[i-1][j][k][w-1]);
                    dp[i][j][k][w]=max(dp[i][j][k][w],dp[i][j-1][k-1][w]);
                    dp[i][j][k][w]=max(dp[i][j][k][w],dp[i][j-1][k][w-1]);
                    if(i!=k||j!=w)
                        dp[i][j][k][w]+=mapp[i][j]+mapp[k][w];
                    else
                        dp[i][j][k][w]+=mapp[i][j];
                }

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

  方法二：降维

        上面的方法明显时间复杂度太高，会超时，所以可以将四维数组转化成三维数组。

        我们可以发现，当走了多少步i确定了，又知道第一路的横坐标为j，第二路的横坐标为k，那么第一路第二路的纵坐标r1，r2都可以写不来，r1=i-j，r2=i-k。所以用dp[i][j][k]就可以替代出上面算法中的dp[i][j][k][w]。

        dp[i][j][k]中，i代表当前走过的步数，j代表第一路的横坐标，k代表第二路的横坐标。

AC代码：

#include<stdio.h>
#include<cstring>
using namespace std;
#define max(a,b) a>b?a:b
const int maxn=205;
int mapp[maxn][maxn];
int dp[maxn+maxn][maxn][maxn];
int main()
{
    int n,m;
    scanf("%d %d",&m,&n);//注意输入时m，n。
    for(int i=1;i<=n;i++){//输入数组时n是行，因为题目要求每行m个数，所以m为列。
        for(int j=1;j<=m;j++){
            scanf("%d",&mapp[i][j]);
        }
    }
    for(int i=2;i<=n+m;i++){//因为i=j+r1，所以要从2开始
        for(int j=1;j<=n&&j<i;j++){
            for(int k=1;k<=n&&k<i;k++){

                dp[i][j][k]=dp[i-1][j][k];
                dp[i][j][k]=max(dp[i][j][k],dp[i-1][j-1][k]);
                dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][k-1]);
                dp[i][j][k]=max(dp[i][j][k],dp[i-1][j-1][k-1]);
                if(j!=k)
                    dp[i][j][k]+=mapp[j][i-j]+mapp[k][i-k];
                else
                    dp[i][j][k]+=mapp[j][i-j];


            }
        }
    }
    printf("%d\n",dp[n+m][n][n]);
    return 0;
}

方法三：滚动数组，降低空间复杂度

空间复杂度有些高，可以用滚动数组降低空间复杂度。

#include<stdio.h>
#include<cstring>
using namespace std;
#define max(a,b) a>b?a:b
const int maxn=205;
int mapp[maxn][maxn];
int dp[2][maxn][maxn];
int main()
{
    int n,m;
    scanf("%d %d",&m,&n);//注意输入时m，n。
    for(int i=1;i<=n;i++){//输入数组时n是行，因为题目要求每行m个数，所以m为列。
        for(int j=1;j<=m;j++){
            scanf("%d",&mapp[i][j]);
        }
    }
    int cur=0;
    for(int i=2;i<=n+m;i++){//因为i=j+r1，所以要从2开始
        cur^=1;
        for(int j=1;j<=n&&j<i;j++){
            for(int k=1;k<=n&&k<i;k++){

                dp[cur][j][k]=dp[cur^1][j][k];
                dp[cur][j][k]=max(dp[cur][j][k],dp[cur^1][j-1][k]);
                dp[cur][j][k]=max(dp[cur][j][k],dp[cur^1][j][k-1]);
                dp[cur][j][k]=max(dp[cur][j][k],dp[cur^1][j-1][k-1]);
                if(j!=k)
                    dp[cur][j][k]+=mapp[j][i-j]+mapp[k][i-k];
                else
                    dp[cur][j][k]+=mapp[j][i-j];


            }
        }
    }
    printf("%d\n",dp[cur][n][n]);
    return 0;
}