方格取数（双状态dp）|| 补充：传纸条，CF213C Relay Race（同类题）

题目链接：

[NOIP2000 提高组] 方格取数 - 洛谷

 [NOIP2008 提高组] 传纸条 - 洛谷

Relay Race - 洛谷

思路：

1.方格取数：

一开始想的是，分两次来dp，第一次和第二次都取最多，第一次取完之后就把格子数字清0，之后写着写着就发现不对，两次取数之间是有影响的，第一次取最多，不一定两次加起来取到最多！所以必须看成两次同时走。由于是同时走，每次只能向下或者向右，所以走到重复格子一定是同时到达！那么就不需要记录已经走过的格子了，只要当走到同一个格子的时候去重就可以。

要想实现两次同时走的效果，就要用到双状态的dp，看成两个人在同时走，dp[ i ][ j ][ k ][ l ]表示第一个人走到( i, j )，第二个人走到( k, l )，递推关系式见代码。

-------------------------------------------------------------------------------------------------------------------------------

2.传纸条

和方格取数类似的思路，这次是需要跳过两个纸条传到同一个地方的情况（起点和终点除外）

---------------------------------------------------------------------------------------------------------------------------

3.Relay Race

方格取数的数据加强版，数组变大，数据有负数，需要用三维数组，并且需要把dp值初始化为-inf

代码：

1.方格取数

#include <iostream>
#include <cmath>
#include <algorithm>

using namespace std;
int g[10][10];
int dp[10][10][10][10]; //dp[i][j][k][l]表示第一个人走到(i,j)，第二个人走到(k,l)时取得最大和
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);

    int n;
    cin >> n;
    int x, y, m; // 横纵坐标和对应数字

    while(cin >> x >> y >> m){
        if(!x && !y && !m) break;
        g[x][y] = m;
    }
    //递推思路：由于两次走会相互影响，所以不能走完一次再走一次，而是应该看成两次一起同步走
    //(i,j)可能是从(i-1,j)或者(i,j-1)两个地方走到的，(k,l)同理，所以有四个状态
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            for(int k=1; k<=n; k++)
                for(int l=1; l<=n; l++){
                    int tmp = max(dp[i-1][j][k-1][l], dp[i-1][j][k][l-1]);
                    tmp = max(tmp, dp[i][j-1][k-1][l]);
                    tmp = max(tmp, dp[i][j-1][k][l-1]);

                    tmp += (g[i][j] + g[k][l]); // 算上当前两个地块的数字
                    if(i==k && j==l) tmp -= g[k][l]; //如果走到同一个地方，需要去重
                    dp[i][j][k][l] = tmp; //记录当前的dp值
                }
    cout << dp[n][n][n][n] << endl;
}

2.传纸条 

#include <bits/stdc++.h>
using namespace std;
int n, m;
int mp[51][51];

//dp[i][j][k][l]表示两张纸条分别在(i,j)，(k,l)位置时，收集到的最大好感数
int dp[51][51][51][51];

int main(){
    cin >> n >> m;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            cin >> mp[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 l=j; l<=m; l++){
                    //检查(i, j)和(k, l)是否重合，如果是就跳过（起点和终点除外）
                    bool flag = true;
                    if(i==k && j==l){
                        flag = false;
                        if(i==1&&j==1) flag = true;
                        else if(i==n && j==m) flag = true;
                    }
                    if(!flag) continue;

                    //两张纸条传到这里的传法有2*2 = 4种，取四个dp值中最大的一个，然后加上当前收集的好感度
                    int tmp = max(dp[i-1][j][k-1][l], dp[i][j-1][k][l-1]);
                    tmp = max(tmp, dp[i-1][j][k][l-1]);
                    tmp = max(tmp, dp[i][j-1][k-1][l]);
                    tmp += (mp[i][j] + mp[k][l]);
                    dp[i][j][k][l] = tmp;
                }
            }
        }
    }
    cout << dp[n][m][n][m];
}

---------------------------------------------------------------------------------------------------------------------------------

11.20补充，实际上不需要四层for循环，因为确定了三个坐标之后，第四个坐标是唯一确定的（如果i+j != k+l，这个dp值其实是无效值，这次就不计算这些无效值了 ），代码如下：

#include <bits/stdc++.h>
using namespace std;
int n, m;
int mp[51][51];

//dp[i][j][k][l]表示两张纸条分别在(i,j)，(k,l)位置时，收集到的最大好感数
int dp[51][51][51][51];

int main(){
    cin >> n >> m;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            cin >> mp[i][j];
        }
    }
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            for(int k=1; k<=n && k<=i+j-1; k++){
                int l = i+j-k; //实际上，通过i，j，k可以唯一确定对应的l，这里可以减少一层循环
                //检查(i, j)和(k, l)是否重合，如果是就跳过（起点和终点除外）
                bool flag = true;
                if(i==k && j==l){
                    flag = false;
                    if(i==1&&j==1) flag = true;
                    else if(i==n && j==m) flag = true;
                }
                if(!flag) continue;
                //两张纸条传到这里的传法有2*2 = 4种，取四个dp值中最大的一个，然后加上当前收集的好感度
                int tmp = max(dp[i-1][j][k-1][l], dp[i][j-1][k][l-1]);
                tmp = max(tmp, dp[i-1][j][k][l-1]);
                tmp = max(tmp, dp[i][j-1][k-1][l]);
                tmp += (mp[i][j] + mp[k][l]);
                dp[i][j][k][l] = tmp;                
            }
        }
    }
    cout << dp[n][m][n][m] << endl;
}

-------------------------------------------------------------------------------------------------------------------------------

3.Relay Race

#include <bits/stdc++.h>
using namespace std;
const int maxn = 301;
int n;
int mp[maxn][maxn];
int dp[2*maxn][maxn][maxn];
int max_4(int a, int b, int c, int d){
    int t1 = max(a, b), t2 = max(c, d);
    return max(t1, t2);
}
signed main(){
    ios::sync_with_stdio(false);
    cin >> n;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++){
            cin >> mp[i][j];
        }
    }
    memset(dp, -0x3f3f3f3f, sizeof(dp));
    dp[1][1][1] = 0; //这里是点(1,0)和(1,0)的初始化，这是无效点，实际作用是把dp值传给dp[2][1][1]
    for(int sum = 2; sum<=2*n; sum++){
        for(int i=1; i<=n && i<sum; i++){
            for(int k=1; k<=n && k<sum; k++){
                int j = sum-i, l = sum-k;
                dp[sum][i][k] = max_4(dp[sum-1][i][k], dp[sum-1][i-1][k], dp[sum-1][i][k-1], dp[sum-1][i-1][k-1]);
                dp[sum][i][k] += (mp[i][j] + mp[k][l]);
                if(i == k) dp[sum][i][k] -= mp[i][j];
            }
        }
    }
    cout << dp[2*n][n][n] << '\n';
}