三次方格取数

多线程DP。

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>
#include <algorithm>
#include <functional>
using namespace std;

/*
    多线程的dp:按照对角线来划分阶段,对于N*N的正方形，则划分的阶段数为2*N-1
    第i阶段的第j个数对应原正方形中下标为(i+1-j,j)
    dp[num][i][j][k]: 表示到达第num个阶段,然后三个人的位置分别为i,j,k时能够取得的最大值
    dp[num][i][j][k] = max(dp[num-1][i][j][k], dp[num-1][i][j][k-1]
                           dp[num-1][i][j-1][k], dp[num-1][i][j-1][k-1]
                           dp[num-1][i-1][j][k], dp[num-1][i-1][j][k-1]
                           dp[num-1][i-1][j-1][k], dp[num-1][i-1][j-1][k-1]) + t
*/

const int maxn = 30;
int arr[maxn][maxn];
int dp[maxn][maxn][maxn][maxn];


int main() {

    freopen("aa.in", "r", stdin);

    int n;
    memset(arr, 0, sizeof(arr));
    memset(dp, 0, sizeof(dp));
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= n; ++j) {
            scanf("%d", &arr[i][j]);
        }
    }
    dp[1][1][1][1] = arr[1][1];
    for(int i = 2; i <= 2*n-1; ++i) {
        for(int j = 1; j <= min(n, i); ++j) {
            for(int k = 1; k <= min(n, i); ++k) {
                for(int l = 1; l <= min(n, i); ++l) {
                    int t = 0;
                    t += arr[i+1-j][j];
                    t += arr[i+1-k][k];
                    t += arr[i+1-l][l];
                    if(j == k) {
                        t -= arr[i+1-j][j];
                    }
                    if(j == l) {
                        t -= arr[i+1-j][j];
                    }
                    if(k == l) {
                        t -= arr[i+1-k][k];
                    }
                    if(j == k && k == l) {
                        t += arr[i+1-j][j];
                    }
                    for(int x1 = -1; x1 <= 0; ++x1) {
                        for(int x2 = -1; x2 <= 0; ++x2) {
                            for(int x3 = -1; x3 <= 0; ++x3) {
                                dp[i][j][k][l] = max(dp[i][j][k][l], dp[i-1][j+x1][k+x2][l+x3] + t);
                            }
                        }
                    }
                }
            }
        }
    }
    printf("%d\n", dp[2*n-1][n][n][n]);
    return 0;
}