最大子阵

这题可以说启发了我深刻的思考。把二维化为一维，把四重循环化为三重循环，非常的其妙。

如果要强行穷举，需要穷举起始点和终止点，那么需要一个四重循环。即使通过二维前缀和来减少计算，那么也要将近500秒的计算时间，稳妥超时。

500^4=62500000000=625*10^8，而 1 秒只能执行10^8的指令，所以这是不可能的。

但是如果化为三重循环，一重循环遍历起始行，二重在起始行的基础上对每行求和，三重求压缩后的最长子串和。就能刚好在1秒内完成。

注意：ans要初始化-Inf，因为题目会给出全是负数的条件。

AC代码：

#include <stdio.h>
#include <memory.h>
#include <math.h>
#include <string>
#include <string.h>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <map>

#define I scanf
#define OL puts
#define O printf
#define F(a,b,c) for(a=b;a<c;a++)
#define FF(a,b) for(a=0;a<b;a++)
#define FG(a,b) for(a=b-1;a>=0;a--)
#define LEN 600
#define MAX 0x06FFFFFF
#define V vector<int>

using namespace std;

int mat[LEN][LEN]; 
int sum[LEN];    //叠加的和 
int dp[LEN];    //当前列的最大和 
int ans=-MAX;

int main(){
//    freopen("D:/CbWorkspace/blue_bridge/最大子阵.txt","r",stdin);
    int N,M,i,j,k;
    I("%d%d",&N,&M) ;
    F(i,1,N+1) F(j,1,M+1) I("%d",&mat[i][j]);
    F(i,1,N+1){    // i 为起始行
        memset(sum,0,sizeof sum) ;
        F(j,i,N+1){    // j  从 i 循环到结束 
            F(k,1,M+1) sum[k]+=mat[j][k];    //叠加这一行
            dp[1]=sum[1];
            ans=max(ans,dp[1]);
            F(k,2,M+1){
                if(dp[k-1]>0){    //能够递增，叠加 
                    dp[k]=dp[k-1]+sum[k];
                }else{
                    dp[k]=sum[k];//放弃这个状态，开始新的 
                }
                ans=max(ans,dp[k]);
            }
        }
    }
    O("%d\n",ans);
    return 0;
}