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=-999999999,minn,zuixiao[N][N][N][N];
int sum[N][N],num[N][N],tot;

inline void read(int &num)
{
    int f=1;
    char c=getchar();
    for(;!isdigit(c);c=getchar()){if(c=='-') f=-1;};
    for(;isdigit(c);c=getchar()){num=num*10+c-'0';};
    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=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            read(num[i][j]);
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+num[i][j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            for(int k=i;k<=n;k++)
            {
                for(int l=j;l<=m;l++)
                {
                    tot=sum[k][l]-sum[i-1][l]-sum[k][j-1]+sum[i-1][j-1];
                    minn=999999999;
                    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 0;
}

正解：

/*
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][2],sum[N][N];

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