棋盘DP三连——洛谷 P1004 方格取数 &&洛谷 P1006 传纸条 &&Codevs 2853 方格游戏

P1004 方格取数

题目描述

设有N $\times N$N×N的方格图(N $\le 9$)(N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字00。如下图所示（见样例）:

A
 0  0  0  0  0  0  0  0
 0  0 13  0  0  6  0  0
 0  0  0  0  7  0  0  0
 0  0  0 14  0  0  0  0
 0 21  0  0  0  4  0  0
 0  0 15  0  0  0  0  0
 0 14  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
                         B

某人从图的左上角的$A$A$点出发，可以向下行走，也可以向右走，直到到达右下角的BB点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字00）。
此人从AA点到BB点共走两次，试找出22条这样的路径，使得取得的数之和为最大。

输入输出格式

输入格式：

输入的第一行为一个整数NN（表示$N \times NN×N$的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的00表示输入结束。

输出格式：

只需输出一个整数，表示22条路径上取得的最大的和。

输入输出样例

输入样例#1： 复制

8
2 3 13
2 6  6
3 5  7
4 4 14
5 2 21
5 6  4
6 3 15
7 2 14
0 0  0

输出样例#1： 复制

67

说明

NOIP 2000 提高组第四题

设计状态为$f[i][j][k][l]$第一个人走到$(i,j)$,第二个人走到$(k,l)$所能获得的最大价值

我们考虑两个人同时走，就相当于数字三角形。状态转移方程为：

$f[i][j][k][l]=max(f[i−1][j][k−1][l],f[i−1][j][k][l−1],f[i][j−1][k−1][l],f[i][j−1][k][l−1])+a[i][j]+a[k][l]$

需要特判一下两个人走到相同位置的时候。

#include<bits/stdc++.h>
#define N 2000001

using namespace std;

void in(int &x){
    char c=getchar();x=;int f=;
    while(!isdigit(c)){if(c=='-') f=-;c=getchar();}
    while(isdigit(c)){x=x*+c-'';c=getchar();}
    x*=f;
}

int n,a[][],f[][][][];

int main()
{
    in(n);
    while(){
        int k,b,c;
        in(k);in(b);in(c);
        if(k==||b==||c==) break;
        a[k][b]=c;
    }
　　for(int i=;i<=n;i++){
        for(int j=;j<=n;j++){
            for(int k=;k<=n;k++){
                for(int l=;l<=n;l++){
                    f[i][j][k][l]=max(max(f[i-][j][k-][l],f[i-][j][k][l-]),max(f[i][j-][k-][l],f[i][j-][k][l-]))+a[i][j]+a[k][l];
                    if(i==k&&j==l) f[i][j][k][l]-=a[i][j];
                }
            }
        }
   }
　　printf("%d",f[n][n][n][n]);
    return ;
}

P1006 传纸条

题目描述

小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。一次素质拓展活动中，班上同学安排做成一个mm行nn列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标(1,1(1,1)，小轩坐在矩阵的右下角，坐标(m,n)(m,n)。从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。

在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。

还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用00表示），可以用一个0-1000−100的自然数来表示，数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这22条路径上同学的好心程度之和最大。现在，请你帮助小渊和小轩找到这样的22条路径。

输入输出格式

输入格式：

输入文件，第一行有22个用空格隔开的整数mm和nn，表示班里有mm行nn列。

接下来的mm行是一个m \times nm×n的矩阵，矩阵中第ii行jj列的整数表示坐在第ii行jj列的学生的好心程度。每行的nn个整数之间用空格隔开。

输出格式：

输出文件共一行，包含一个整数，表示来回22条路上参与传递纸条的学生的好心程度之和的最大值。

输入输出样例

输入样例#1： 复制

3 3
0 3 9
2 8 5
5 7 0

输出样例#1： 复制

34

说明

【限制】

30%的数据满足：$1 \le m,n \le 101≤m,n≤10$

100%的数据满足：$1 \le m,n \le 501≤m,n≤50$

NOIP 2008提高组第三题

显然，这题跟上一题一样，就是题意换了换,数据范围扩大了点。

#include<cstdio>
#include<cstring>
#include<iostream>
#define N 2000001

using namespace std;

void in(int &x){
    char c=getchar();x=;int f=;
    while(!isdigit(c)){if(c=='-') f=-;c=getchar();}
    while(isdigit(c)){x=x*+c-'';c=getchar();}
    x*=f;
}

int n,a[][],f[][][][],m;

int main()
{
    in(n);in(m);
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            in(a[i][j]);
        }
    }for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            for(int k=;k<=n;k++){
                for(int l=;l<=m;l++){
                    f[i][j][k][l]=max(max(f[i-][j][k-][l],f[i-][j][k][l-]),max(f[i][j-][k-][l],f[i][j-][k][l-]))+a[i][j]+a[k][l];
                    if(i==k&&j==l) f[i][j][k][l]-=a[i][j];
                }
            }
        }
    }printf("%d",f[n][m][n][m]);
    return ;
}

2853 方格游戏

题目描述 Description

菜菜看到了一个游戏，叫做方格游戏~

游戏规则是这样的：

在一个n*n的格子中，在每个1*1的格子里都能获得一定数量的积分奖励，记左上角为(1,1)，右下角为(n,n)。游戏者需要选择一条(1,1)到(n,n)的路径，并获得路径上奖励的积分。对于路径当然也有要求啦，要求是只能往坐标变大的方向走【从(x,y)到(x+1,y)或者(x,y+1)】，走过2n-1个区域到达(n,n)。当然，获得的积分最高的就能取胜啦。

这时，菜菜看到了他的好友月月，于是邀请她来玩双人版的。双人版的规则就是在单人版的基础上加上一条两人的路线不能相同。月月知道菜菜的很聪明，怕输得太惨，就不太愿意和他玩。菜菜可慌了，于是定义了一个公平值D，这个公平值等于俩人所选择的路径所能获得的积分一一对应相减的差的绝对值之和，即D=sigma (|kxi-kyi|)|(kx，ky分别为菜菜，月月走过的每一个区域的丛林系数）。不过这可是个庞大的计算任务，菜菜找到了你，请你帮忙计算公平值的最大值。

输入描述 Input Description

第一行，一个正整数n

接下来的n行，每行n个整数，表示丛林中每个区域的公平值

输出描述 Output Description

一个整数Dmax，即公平值的最大值

样例输入 Sample Input

4

1 2 3 4

1 5 3 2

8 1 3 4

3 2 1 5

样例输出 Sample Output

13

数据范围及提示 Data Size & Hint

对于20%的数据，保证0＜n≤20

对于50%的数据，保证0＜n≤50

对于100%的数据，保证0＜n≤100且对于所有的i，j保证|Kij|≤300

显然这是上两个题的加强版，四维DP肯定过不了。

四维DP——50——RE&&TLE

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define N 100

using namespace std;

void in(int &x){
    char c=getchar();x=;int f=;
    while(!isdigit(c)){if(c=='-') f=-;c=getchar();}
    while(isdigit(c)){x=x*+c-'';c=getchar();}
    x*=f;
}

int n,a[N][N],f[N][N][N][N],m;

int main()
{
    in(n);m=n;
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            in(a[i][j]);
        }
    }
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            for(int k=;k<=n;k++){
                for(int l=;l<=m;l++){
                    f[i][j][k][l]=max(max(f[i-][j][k-][l],f[i-][j][k][l-]),max(f[i][j-][k-][l],f[i][j-][k][l-]))+abs(a[i][j]-a[k][l]);
                }
            }
        }
    }
    printf("%d",f[n][m][n][m]);
    return ;
}

解题思想：

DP相对于搜索快捷的原因在于他记录了一些搜索到的值，不需要重复搜索，而dp相对于记忆化搜索要快在于dp比它多了高效的顺序，从子结构到总结构，保证每个状态只被搜索到一次。 优化dp我们就要从状态入手，状态表达地越简练就越快。

状态设计：$f[k][i][j]$表示走了k步，第一个人走到了第$i$行，第二个人走到了第$j$行所能获得的最大公平值

考虑如何转移：首先$f[k][i][j]$可以表示第一个人的坐标为$(i,k-i+2)$,第二个人的坐标为$(j,k-j+2)$

1.第一个人从上转移下来 $f[k-1][i-1][j]$

2.第二个人从上转移下来 $f[k-1][i][j-1]$

3.两个人同时从上转移下来 $f[k-1][i-1][j-1]$

4.两个人同时从左转移下来 $f[k-1][i][j]$

$F[k][i][j]=Max(f[k-1][i-1][j],f[k-1][i][j-1],f[k-1][i-1][j-1],f[k-1][i][j])+abs(a[i][k-i+2]-a[j][k-j+2])$

状态：（向右，向右）（向下，向右）（向右，向下）（向下，向下）

代码实现：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define N 200

using namespace std;

void in(int &x){
    char c=getchar();x=;int f=;
    while(!isdigit(c)){if(c=='-') f=-;c=getchar();}
    while(isdigit(c)){x=x*+c-'';c=getchar();}
    x*=f;
}

int n,a[N][N],f[N*][N][N],m;

int main()
{
    in(n);
    for(int i=;i<=n;i++)
        for(int j=;j<=n;j++)
            in(a[i][j]);

    for(int k=;k<=*n-;k++){
        for(int i=;i<=n&&i<=k+;i++){
            for(int j=;j<=n&&j<=k+;j++){
                f[k][i][j]=max(f[k][i][j],max(max(f[k-][i][j-],f[k-][i-][j]),max(f[k-][i-][j-],f[k-][i][j])))+abs(a[i][k-i+]-a[j][k-j+]);
            }
        }
    }
    printf("%d",f[*n-][n][n]);
    return ;
}

参考博客：Counting__Stars