SPOJ 274 Johnny and the Watermelon Plantation（TLE）

O(n^3)的时间复杂度，改了半天交了二三十遍，TLE到死，实在没办法了……

跪求指点！！！

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>

 using namespace std;

 const int MAXN = ;
 const int INF =  << ;

 int mat[MAXN][MAXN];
 int SubSum[MAXN][MAXN];
 int tempS[MAXN];
 int N, K;
 int maxI, maxJ;
 int hang[MAXN], cntH;
 int lie[MAXN], cntL;

 //预处理左上角[1,1]右下角[i,j]的所有矩阵和
 void init()
 {
     memset( SubSum, , sizeof(SubSum) );
     for ( int i = ; i <= maxI; ++i )
     {
         int tmps = ;
         for ( int j = ; j <= maxJ; ++j )
         {
             tmps += mat[i][j];
             SubSum[i][j] = SubSum[i - ][j] + tmps;
         }
     }
     return;
 }

 void solved()
 {
     int ans = INF;
     for ( int i = ; i < cntH; ++i ) //枚举矩形上边界
     for ( int j = i; j < cntH; ++j )  //枚举矩形下边界
     {
         int stL = hang[i], edL = hang[j];
         tempS[] = ;
         int st = ;
         //扫描法，参考刘汝佳训练指南p.48 LA 2678
         for ( int m = ; m <= cntL; ++m )
         {
             int k = lie[m - ];
             tempS[m] = SubSum[edL][k] - SubSum[edL][k-] - SubSum[stL-][k] + SubSum[stL-][k-];
             tempS[m] += tempS[m - ];
             if ( tempS[st - ] > tempS[m] - K ) continue;
             while ( tempS[st] <= tempS[m] - K ) ++st;
             ans = min( ans, ( lie[m - ] - lie[st - ] ) * ( edL - stL ) );
         }
     }
     printf( "%d\n", ans );
     return;
 }

 int main()
 {
     //freopen( "in.txt", "r", stdin );
     int T;
     scanf( "%d", &T );
     while ( T-- )
     {
         memset( mat, , sizeof(mat) );
         scanf( "%d%d", &N, &K );
         maxI = ;
         maxJ = ;
         cntL = , cntH = ;
         bool flag = false;
         for ( int i = ; i < N; ++i )
         {
             int x, y, f;
             scanf("%d%d%d", &x, &y, &f );
             hang[cntH++] = x;  //行列离散化
             lie[cntL++] = y;
             maxI = max( maxI, x );
             maxJ = max( maxJ, y );
             mat[x][y] = f;
             if ( f >= K )  //特殊情况，只覆盖一个点
             {
                 flag = true;
             }
         }

         if ( N ==  || flag )
         {
             puts("");
             continue;
         }

         sort( hang, hang + cntH );
         sort( lie, lie + cntL );
         cntH = unique( hang, hang + cntH ) - hang;
         cntL = unique( lie, lie + cntL ) - lie;

         init();
         solved();
     }
     return ;
 }