uva 10755 Garbage Heap

https://vjudge.net/problem/UVA-10755

题意：

给出一个长方体，叫你求哪个子矩阵的和最大，输出的是最大值。

思路：

首先，n的规模是20，那么最常规的算法，枚举起点，枚举终点，之后循环计算，那么这个的复杂度就是O(N^9)。

这个想法其实是比较自然的，那么可以加一些优化进去，减小复杂度。

首先，三维的问题，可以通过降维解决，枚举竖坐标，降成一维解决。

降成一维之后，如果还是枚举起点与终点，那么复杂度还是高达O(N^8)。

那么其实坐标平面的问题可以用前缀和来优化，所以再用上前缀和优化。

之后，最大子矩阵就可以用动态规划解决了。

tmp = sum[i][j] - sum[k-1][j]，这里的sum记录的是降维之后的前缀和，然后k从1到x枚举，i从k到x枚举，j从1到y枚举，

这个操作把一个矩阵变成了一条线，于是就用最大连续和的思想解决。

总的复杂度是O(N^5)。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

long long a[25][25][25];

long long b[25][25];
long long sum[25][25];

int main()
{
    int t;

    scanf("%d",&t);

    while (t--)
    {
        long long ans = -1e18;

        int x,y,z;

        scanf("%d%d%d",&x,&y,&z);

        for (int i = 1;i <= x;i++)
            for (int j = 1;j <= y;j++)
            for (int k = 1;k <= z;k++)
            scanf("%lld",&a[i][j][k]);

        for (int i = 1;i <= z;i++)
            for (int j = i;j <= z;j++)
        {
            memset(b,0,sizeof(b));

            for (int k = i;k <= j;k++)
            {
                for (int m = 1;m <= x;m++)
                    for (int n = 1;n <= y;n++)
                    b[m][n] += a[m][n][k];
            }

            memset(sum,0,sizeof(sum));

            for (int m = 1;m <= x;m++)
                for (int n = 1;n <= y;n++)
            {
                sum[m][n] = sum[m-1][n] + sum[m][n-1] - sum[m-1][n-1] + b[m][n];
            }

            for (int m = 1;m <= x;m++)
                for (int n = m;n <= x;n++)
            {
                long long orz = 0;

                for (int k = 1;k <= y;k++)
                {
                    long long tmp = sum[n][k] - sum[m-1][k];

                    ans = max(ans,tmp - orz);

                    orz = min(tmp,orz);
                }
            }
        }

        printf("%lld\n",ans);

        if (t) printf("\n");
    }

    return 0;
}