2017.10.3 国庆清北 D3T3 解迷游戏

题目描述

LYK进了一家古董店，它很想买其中的一幅画。但它带的钱不够买这幅画。

幸运的是，老板正在研究一个问题，他表示如果LYK能帮他解出这个问题的话，就把这幅画送给它。

老板有一个n*m的矩阵，他想找一个和最大的子矩阵，这个子矩阵可以由四个参数x,y,x2,y2(1<=x<=x2<=n,1<=y<=y2<=m)来表示，表示一个左上角为(x,y)，右下角为(x2,y2)的矩阵。

为了让游戏更加有趣，老板给了一个常数P，他想将原来这个矩阵中恰好一个数变为P，使得这个矩阵的最大的子矩阵尽可能大。

老板想知道这个最大值是多少。

你能帮帮LYK吗？

输入输出格式

输入格式：

第一行三个数n,m,P。

接下来n行，每行m个数ai,j描述整个矩阵。

输出格式：

输出一个数表示答案。

输入输出样例

输入样例#1：

3 3 3
-100 3 3
3 -4 3
3 3 3

输出样例#1：

20

样例解释
改变左上角那个数。

说明

对于20%的数据n,m<=10。

对于40%的数据n,m<=25。

对于60%的数据n,m<=50。

对于80%的数据n,m<=100。

对于100%的数据1<=n,m<=300，|P|,|ai,j|<=1000。

40分暴力：

 /*预处理出二维前缀和，枚举每个矩阵，当前矩阵的元素和tot可以用预处理出来的前缀和算出来，然后找每个矩阵中的最小值minn，如果这个最小值minn小于p，那么就将它改为p，tot=tot-minn+p,否则不改。 Ans=max(ans,tot)
 时间复杂度O(n^3*m^3)*/
 #include<iostream>
 #include<cmath>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<string>
 #define N 65
 using namespace std;

 int n,m,p,ans=-,minn,zuixiao[N][N][N][N];
 int sum[N][N],num[N][N],tot;

 inline void read(int &num)
 {
     int f=;
     char c=getchar();
     for(;!isdigit(c);c=getchar()){if(c=='-') f=-;};
     for(;isdigit(c);c=getchar()){num=num*+c-'';};
     num*=f;
 }

 inline int _max(int a,int b)
 {
     return a>b?a:b;
 }

 inline int _min(int a,int b)
 {
     return a<b?a:b;
 }

 int main()
 {
     freopen("puzzle.in","r",stdin);
     freopen("puzzle.out","w",stdout);
     read(n),read(m),read(p);
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++)
         {
             read(num[i][j]);
         }
     }
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++)
         {
             sum[i][j]=sum[i-][j]+sum[i][j-]-sum[i-][j-]+num[i][j];
         }
     }
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++)
         {
             for(int k=i;k<=n;k++)
             {
                 for(int l=j;l<=m;l++)
                 {
                     tot=sum[k][l]-sum[i-][l]-sum[k][j-]+sum[i-][j-];
                     minn=;
                     for(int a=i;a<=k;a++)
                     {
                         for(int b=j;b<=l;b++)
                         {
                             minn=_min(minn,num[a][b]);
                         }
                     }
                     if(minn<p) tot=tot-minn+p;
                     ans=_max(ans,tot);
                 }
             }
         }
     }
     printf("%d",ans);
     fclose(stdin);
     fclose(stdout);
     return ;
 }

正解：

 /*
 n^2前缀和+n^2预处理矩阵最小值+n^3求解
 复杂度 O(n^3)
 */
 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 #define N 305
 #define INF -999999999
 using namespace std;

 int n,m,ans,p;
 int a[N][N],b[N],minn[N],dp[N][],sum[N][N];

 int main()
 {
     scanf("%d",&n);
     ans=INF;
     scanf("%d%d",&m,&p);
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++)
         {
             scanf("%d",&a[i][j]);
         }
     }
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++)
         {
             sum[i][j]=sum[i-][j]+a[i][j];
         }
     }
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++) minn[j]=a[i][j];
         for(int j=i;j<=n;j++)
         {
             for(int k=;k<=m;k++) minn[k]=min(minn[k],a[j][k]);
             for(int k=;k<=m;k++) b[k]=sum[j][k]-sum[i-][k];
             dp[][]=INF;
             for(int k=;k<=m;k++)
             {
                 dp[k][]=max(dp[k-][]+b[k],b[k]);
                 dp[k][]=max(max(dp[k-][]+b[k],dp[k-][]+b[k]-minn[k]+p),b[k]-minn[k]+p);
             }
             for(int k=;k<m;k++) ans=max(ans,max(dp[k][],dp[k][]));
             if(i==&&j==n)
             {
                 ans=max(ans,dp[m][]);
                 int sum=;
                 for(int k=m;k>;k--)
                 {
                     sum+=b[k];
                     ans=max(ans,sum);
                 }
             }
             else ans=max(ans,max(dp[m][],dp[m][]));
         }
     }
     printf("%d\n",ans);
     return ;
 }