hihocoder 1634

题意： 题意：给一个n*m的矩阵，其最大子矩阵为矩阵内所有值的和最大的一个子矩阵，现给一个值p，从矩阵中任选一个值替换为p或者不操作，问所有可能操作结果矩阵的最大子矩阵和的最小值为多少

思路：min -max 枚举的思路。

          min  { max( maxval - a[i][j] + v,     left[ j-1 ]   ,   right[ j+1 ]  ,   up[ i-1 ]  ,    down[ i+1 ] ) }

           1 <= i <= n

           1 <= j <= m

          只要能够保证能够枚举到正确的答案,对于答案上市一定是正确的。但是如果对于枚举的不是答案的点，上式存在问题，不过并不会影响最后答案的统计，因为最后所有的枚举最后取min,上式对于别的枚举只会使得答案偏大，不会影响
最终答案的统计。

          min - max 枚举在最小化和最大化问题中是一种很常见的思路。

          矩阵的旋转操作可以简化代码，不过容易被转蒙，一种很好的解决方案是画图时在一条边标记上边的方向。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
const int maxm = 200;
const int inf = 0x3f3f3f3f;
int tmp[maxn][maxn][maxn],sum[maxn][maxn];
int mx = inf,ans;
void calc( int n,int m,int dp[maxn],int a[maxn][maxm] ){
    memset( sum,0,sizeof(sum) );
    dp[0] = -inf;
    for( int i = 1;i <= n;i++ ){
        for( int j = 1;j <= m;j++ ){
            sum[i][j] = sum[i-1][j] + a[i][j];
        }
    }

    for( int i = 1;i <= m;i++ ){
        int cur = -inf;
        for( int j = 1;j <= n;j++ ){
            for( int k = j;k <= n;k++ ){
                tmp[i][j][k] = (tmp[i-1][j][k] > 0 ? tmp[i-1][j][k] : 0) + sum[k][i] - sum[j-1][i] ;
                cur = max( tmp[i][j][k],cur );
            }
        }
        dp[i] = max( dp[i-1],cur );
    }
    ans = mx = min( mx,dp[m] );
}
int up[maxn],down[maxn],le[maxn],ri[maxn],a[maxn][maxn],b[maxn][maxn],c[maxn][maxn],p;
void solve( int n,int m ){
    for( int i = 1;i <= n;i++ ){
        for( int j = 1;j <= m;j++ ){
            if( p < c[i][j] )
            ans = min(ans,max( max( max( max( mx-c[i][j]+p,le[j-1] ),ri[m-j] ),up[i-1] ),down[n-i] ));
        }
    }
};
int main(){
    int n,m;
    while(3 == scanf("%d%d%d",&n,&m,&p)) {
        mx = ans = inf;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                scanf("%d", &a[i][j]);
                c[i][j] = a[i][j];
            }
        }
        calc(n, m, le, a);
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                b[i][j] = a[j][i];
            }
        }
        calc(m, n, up, b);
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m / 2; j++) {
                swap(a[i][j], a[i][1 + m - j]);
            }
        }
        calc(n, m, ri, a);
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n / 2; j++) {
                swap(b[i][j], b[i][1 + n - j]);
            }
        }
        calc(m, n, down, b);
        solve(n, m);
        printf("%d\n", ans);
    }
    return 0;
}