吃西瓜 最大子矩阵 三维的。 rqnoj93

     真的好苦逼，这道神题，交了几十次都是70分，剩下的都TLE了，崩溃。

     没办法，只能这样了。在网上看了别人的算法，大概思想是把三维的先压成两维，再把二维的弄成一维，这样就很容易了。

     首先先累计从最底层到第i层的值，然后枚举i，j把第i层到第j层之间的值的和都算出来，就降成了二维，然后再去类似的枚举，降成简单的一维。

     从这道题中学到了

    1 输入优化是很重要的。

    2 根据题目特点，可采取更优的循环方式。

    3 max不能滥用，最好还是用比较的方式，效率比较高。

    4 inline应该是有用。

#include<cstdio>
#include<cctype>
#include<cstring>
#define rep(i,j,k) for(int i = j; i <= k; i++)
#define maxn 60
using namespace std;

int key[maxn][maxn][maxn], f[maxn][maxn] = {0}, dp[maxn];
int h, x, y;

inline int read() //重要的输入优化
{
    int s = 0, t = 1; char c = getchar();
    while( !isdigit(c) ){
        if( c == '-' ) t = -1; c = getchar();
    }
    while( isdigit(c) ){
        s = s * 10 + c - '0'; c = getchar();
    }
    return s * t;
}

int maxsum3()
{
    int ans = -0xfffffff;
    rep(i,1,h){
        rep(j,i,h){
            rep(k,1,x){
                rep(l,1,y){
                    f[k][l] = key[j][k][l] - key[i-1][k][l];
                }
            }
            //重要优化所在，不要枚举k和l之间的所有值，把他们一次性算出来后，清零，下一次再重算，而是采用这种不断累加的方式。
            rep(k,1,x){
                memset(dp,0,sizeof(dp));
                rep(l,k,x){
                    rep(t,1,y) dp[t] += f[l][t];
                    int sum = 0;
                    rep(t,1,y){
                        if( sum > 0 ) sum += dp[t];
                        else sum = dp[t];
                        if( ans < sum ) ans = sum;
                    }
                }
            }
        }
    }
    return ans;
}

int main()
{
    h = read(), x = read(), y = read();
    rep(i,1,h){
        rep(j,1,x){
            rep(k,1,y){
                key[i][j][k] = read();
                key[i][j][k] += key[i-1][j][k];
            }
        }
    }
    int ans = maxsum3();
    printf("%d
", ans);
    return 0;
}

  多学，多积累，加油。