[CTSC2002] 颁奖典礼

0.我为什么要写这篇博客

因为我太菜了，网上其他的有关于这道题的博客全都看不懂
而且写博客的人都比较巨，比如说 $kaiser$神仙（orz您）
后来我在 $akioi$的 $gjm$的帮助下理解了这道题（IOI选手果然是轻松切掉ctsc题）

1.O(nm^4)算法

题目链接

题目大意就是给你一个 $n\times m$的01矩阵，让你求出最大的完全由0构成的 $I$字形区域的面积

这道题我们很明显可以把问题简化一下，变成处理三个矩形，那么状态我们就设计出来了
$f[i][j][k][l](l=1,2,3)$表示我们现在取第 $i$行的 $[j,k]$这一段，作为第 $l$个矩形的一部分
为了判断这一段是不是全是0，我们可以开一个数组 $sum[i][j]$表示第 $i$行，前 $j$个数的和

那么转移就差不多是这个样子的
$f[i][j][k][l]=max\{ f[i-1][j][k][l],f[i-1][x][y][l-1]\}+k-j+1(sum[i][k]=sum[i][j-1])$
就是说，在第 $i$层这个区间的状态，可以通过上一层的继承过来，也可以通过上一个矩形的一个区间继承过来，这个区间需要满足相应的条件（我们下面说），在加上这一区间的长度，因为我们每次只扩展一行

这样的话我们会得到一个 $O(nm^4)$的算法，但是 $n\leq200$我们至少要把他优化到 $O(nm^2log)$级别（当然这道题很明显不带 $log$）

2.O(nm^2)算法

2.1 g数组

这里我们看一下， $I$是一个什么样的结构，比如说我们设这3个矩形的左右端点分别是 $[l_1,r_1]$, $[l_2,r_2]$, $[l_3,r_3]$（高度我们先不管他）
那么，为了满足 $I$字形的条件，中间那个矩形要比两边的都要窄，也就是说
$l_1<l_2\leq r_2<r_1,l_3<l_2\leq r_2<r_3$
这也是在刚才 $O(nm^4)$的算法中转移时 $x,y$的要求

那么为了优化，我们可以记录一下之前在这些区间里的最大矩形的面积，所以我们开一个辅助数组
$g[j][k][l](l=1,2)$
$g[j][k][1]$表示在上一行中，包含区间 $[j,k]$的最大面积
$g[j][k][2]$表示，在上一行中，被区间 $[j,k]$包含的最大面积

我们看一下为什么这样可以减少复杂度
在由第一个矩阵转向第二个矩阵的时候，我们之前循环的 $x,y$一定是要完全包含第二个矩阵的，那么我们在第二个矩阵循环 $x,y$的时候，就可以直接通过调用 $g$数组来避免循环 $x,y$
比如对于区间 $[l_2,r_2]$他的上一个最大的满足条件的就是 $g[l_2-1][r_2+1][1]$，为什么要两边都增加一个呢？因为我们定义 $g$数组的时候定义的是闭区间，但是这里要求的是开区间（因为两边都不能相等）
对于第三个矩阵向第二个矩阵转移的时候也是一样的

2.2 g数组的转移

我们再来看看 $g$数组如何转移

很明显 $g$数组是由 $f$数组转移过来的，那么我们就可以得到一个转移方程
$g[j][k][1]=max\{f[i][j][k][1],g[j-1][k][1],g[j][k+1][1]\}$
首先，包含区间 $[j,k]$的可以是它本身，即 $f[i][j][k][1]$，也可以是它左右转移过来，但是必须包含，就是 $g[j-1][k][1]$和 $g[j][k+1][1]$这三种情况取个 $max$就可以了

对于第二个矩阵往第三个矩阵转移，其实是差不多的
$g[j][k][2]=max\{f[i][j][k][2],g[j+1][k][2],g[j][k-1][2]\}$

2.3 初值与循环顺序

初值
$f,g$都要赋成 $-inf$，为什么不能是0呢？因为我们发现，第二个矩阵必需由第一个矩阵做完了才能轮到他，第三个必需要等第二个矩阵做完了，如果设成0的话我们就不知道他该不该做了

循环顺序
循环顺序要注意的地方主要是两个
一个是 $l$那一维，我们要从3到1循环，为什么呢？其实跟初值问题是一样的，如果先把1更新完了，g数组就不正确了，就是下一行的g数组了

还有一个就是 $g$数组的转移顺序，看他的转移方程，比如以第一个矩形到第二个矩形的为例
我们做 $g[j][k][1]$的时候，我们必须确保 $g[j-1][k][1]$, $g[j][k+1][1]$都已知
所以我们需要让 $j$倒序循环， $k$正序循环
对于 $g[j][k][2]$，反过来就可以啦

2.4 代码

# include <cstdio>
# include <algorithm>
# include <cstring>
# include <cmath>
# include <climits>
# include <iostream>
# include <string>
# include <queue>
# include <stack>
# include <vector>
# include <set>
# include <map>
# include <cstdlib>
# include <ctime>
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;
const int N=205;
const int inf=0x7fffffff;
const double eps=1e-7;
template <typename T> void read(T &x){
	x=0;int f=1;
	char c=getchar();
	for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
	for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
	x*=f;
}

int n,m,ans;
int f[N][N][N][4],g[N][N][3];
int sum[N][N];

int main()
{
	read(n),read(m);
	Rep(i,1,n)
		Rep(j,1,m){
			int x;
			read(x);
			sum[i][j]=sum[i][j-1]+x;
		}
	memset(f,-0x3f,sizeof(f));
	memset(g,-0x3f,sizeof(g));
	Rep(i,1,n)
		_Rep(which,3,1){
			Rep(j,1,m)
				Rep(k,j,m)
					if(sum[i][k]==sum[i][j-1]){
						if(which==1)f[i-1][j][k][which]=max(f[i-1][j][k][which],0);
						f[i][j][k][which]=f[i-1][j][k][which]+k-j+1;
						if(which==2)f[i][j][k][which]=max(g[j-1][k+1][which-1]+k-j+1,f[i][j][k][which]);
						if(which==3)f[i][j][k][which]=max(g[j+1][k-1][which-1]+k-j+1,f[i][j][k][which]);
					}
			if(which==1)
				Rep(j,1,m)
					_Rep(k,m,j)
						g[j][k][1]=max(f[i][j][k][1],max(g[j-1][k][1],g[j][k+1][1]));
			if(which==2)
				_Rep(j,m,1)
					Rep(k,j,m)
						g[j][k][2]=max(f[i][j][k][2],max(g[j+1][k][2],g[j][k-1][2]));
			if(which==3)
				Rep(j,1,m)
					Rep(k,1,m)
						ans=max(ans,f[i][j][k][3]);
		}
	printf("%d\n",ans);
	return 0;
} 

3.空间优化

虽然上面的代码已经可以在 $bzoj$上过了，但是空间复杂度并不是很优， $bzoj$上的空间限制是256mb，如果变成128就会被卡掉qwq

所以一个很好想的优化就出来了——滚动数组，我们可以把 $f$的 $i$那一维给滚掉

但是注意要每次做的时候要把当前行再赋一次初值 $-inf$

# include <cstdio>
# include <algorithm>
# include <cstring>
# include <cmath>
# include <climits>
# include <iostream>
# include <string>
# include <queue>
# include <stack>
# include <vector>
# include <set>
# include <map>
# include <cstdlib>
# include <ctime>
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;
const int N=205;
const int inf=0x7fffffff;
const double eps=1e-7;
template <typename T> void read(T &x){
	x=0;int f=1;
	char c=getchar();
	for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
	for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
	x*=f;
}

int n,m,ans,x;
int f[2][N][N][4],g[N][N][3];
int sum[N][N];

int main()
{
	read(n),read(m);
	Rep(i,1,n)
		Rep(j,1,m){
			int x;
			read(x);
			sum[i][j]=sum[i][j-1]+x;
		}
	memset(f,-0x3f,sizeof(f));
	memset(g,-0x3f,sizeof(g));
	Rep(i,1,n){
		memset(f[x],-0x3f,sizeof(f[x]));//记得赋初值
		_Rep(which,3,1){
			Rep(j,1,m)
				Rep(k,j,m)
					if(sum[i][k]==sum[i][j-1]){
						if(which==1)f[x^1][j][k][which]=max(f[x^1][j][k][which],0);
						f[x][j][k][which]=f[x^1][j][k][which]+k-j+1;
						if(which==2)f[x][j][k][which]=max(g[j-1][k+1][which-1]+k-j+1,f[x][j][k][which]);
						if(which==3)f[x][j][k][which]=max(g[j+1][k-1][which-1]+k-j+1,f[x][j][k][which]);
					}
			if(which==1)
				Rep(j,1,m)
					_Rep(k,m,j)
						g[j][k][1]=max(f[x][j][k][1],max(g[j-1][k][1],g[j][k+1][1]));
			if(which==2)
				_Rep(j,m,1)
					Rep(k,j,m)
						g[j][k][2]=max(f[x][j][k][2],max(g[j+1][k][2],g[j][k-1][2]));
			if(which==3)
				Rep(j,1,m)
					Rep(k,1,m)
						ans=max(ans,f[x][j][k][3]);
		}
		x^=1;//滚动数组
	}
	printf("%d\n",ans);
	return 0;
} 

这样就不会被空间卡掉了QAQ

4. 写在最后

感谢gjm给我的这道题的解释
以及https://www.cnblogs.com/butterflydew/p/9372076.html——唯一一篇我看懂了的题解