P1004 方格取数

题目描述
设有 N \times NN×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
某人从图的左上角的 AA 点出发，可以向下行走，也可以向右走，直到到达右下角的 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 提高组第四题

*这道题一开始看到就像用两次dp来做，第一次走到终点，算出最大距离，并把走过的方格置为
0，然后第二次从起点开始再用一次dp.后来有个数据死活A不了，百思不得其解，下载了一组测试用例，在草稿纸上花了图才知道求的不是最优解。

测试用例如下：
7
1 3 2
1 4 3
2 3 3
3 3 3
5 5 4
6 5 4
7 3 2
7 5 4
0 0 0

原本是要输出 25 但是这个只能输出23

两次dp代码如下：

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    int s[20][20];
    memset(s,0, sizeof(s));
    int dp[20][20]; //dp[i][j]表示(1,1)--(N,N)的最大值
    int N;
    cin>>N;
    int a,b,c;
    memset(dp,0, sizeof(dp));
    memset(s,0, sizeof(s));
    int sum=0;
    while(cin>>a>>b>>c&&a||b||c)
    {

        s[a][b]=c;
    }
    int Max_i,Max_j;
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            dp[i][j]=max(dp[i-1][j],dp[i][j-1])+s[i][j];
            if(i==N&&j==N)
            {
                Max_i=dp[i-1][j]>dp[i][j-1] ? i-1:i;
                Max_j=dp[i-1][j]>dp[i][j-1] ? j:j-1;
                sum=dp[N][N];
                s[N][N]=0;
            }
        }
    }


    while((Max_i!=1||Max_j!=1)&&Max_i>=1&&Max_i<=N&&Max_j>=1&&Max_j<=N)
    {
        s[Max_i][Max_j]=0;
        int temp_i=Max_i;
        int temp_j=Max_j;
        Max_i=dp[temp_i][temp_j-1]>dp[temp_i-1][temp_j] ? temp_i:temp_i-1;
        Max_j=dp[temp_i][temp_j-1]>dp[temp_i-1][temp_j] ? temp_j-1:temp_j;
    }
    s[1][1]=0;
    memset(dp,0, sizeof(dp));

    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            dp[i][j]=max(dp[i-1][j],dp[i][j-1])+s[i][j];

        }
}

    sum=sum+dp[N][N];
    cout<<sum<<endl;
    return 0;

}

下面我画一张图来解释为什么不能两次dp

上图是上面那一组不能通过的测试用例，正确的走法是如下图所示

这题我们要两个人同时走，可能分别走也可以，是我没想出来？

#include <iostream>
#include <cstring>
using namespace std;
    int main()
    {
        int s[20][20];
        memset(s,0, sizeof(s));
        int dp[20][20][20];
        int N;
        cin>>N;
        int a,b,c;
        memset(dp,0, sizeof(dp));
        memset(s,0, sizeof(s));
        while(cin>>a>>b>>c&&a||b||c)
        {

            s[a][b]=c;
        }
        for(int k=2;k<=N+N;k++)
        {
            for(int i1=1;i1<=N;i1++)
            {
                for(int i2=1;i2<=N;i2++)
                {
                    if(k-i1<=N&&k-i1>=1&&k-i2<=N&&k-i2>=1)
                    {
                        int temp=s[i1][k-i1];
                        if(i1!=i2)
                        {
                            temp+=s[i2][k-i2];
                        }
                        dp[k][i1][i2]=max(dp[k][i1][i2],dp[k-1][i1-1][i2-1]+temp);
                        dp[k][i1][i2]=max(dp[k][i1][i2],dp[k-1][i1][i2-1]+temp);
                        dp[k][i1][i2]=max(dp[k][i1][i2],dp[k-1][i1-1][i2]+temp);
                        dp[k][i1][i2]=max(dp[k][i1][i2],dp[k-1][i1][i2]+temp);
                    }
                }
            }
        }
        cout<<dp[N+N][N][N];
        return 0;
    }