因为我太菜了,网上其他的有关于这道题的博客全都看不懂
而且写博客的人都比较巨,比如说 k a i s e r kaiser kaiser神仙(orz您)
后来我在 a k i o i akioi akioi的 g j m gjm gjm的帮助下理解了这道题(IOI选手果然是轻松切掉ctsc题)
题目链接
题目大意就是给你一个 n × m n\times m n×m的01矩阵,让你求出最大的完全由0构成的 I I I字形区域的面积
这道题我们很明显可以把问题简化一下,变成处理三个矩形,那么状态我们就设计出来了
f [ i ] [ j ] [ k ] [ l ] ( l = 1 , 2 , 3 ) f[i][j][k][l](l=1,2,3) f[i][j][k][l](l=1,2,3)表示我们现在取第 i i i行的 [ j , k ] [j,k] [j,k]这一段,作为第 l l l个矩形的一部分
为了判断这一段是不是全是0,我们可以开一个数组 s u m [ i ] [ j ] sum[i][j] sum[i][j]表示第 i i i行,前 j j j个数的和
那么转移就差不多是这个样子的
f [ i ] [ j ] [ k ] [ l ] = m a x { f [ i − 1 ] [ j ] [ k ] [ l ] , f [ i − 1 ] [ x ] [ y ] [ l − 1 ] } + k − j + 1 ( s u m [ i ] [ k ] = s u m [ i ] [ j − 1 ] ) 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]) 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 i i层这个区间的状态,可以通过上一层的继承过来,也可以通过上一个矩形的一个区间继承过来,这个区间需要满足相应的条件(我们下面说),在加上这一区间的长度,因为我们每次只扩展一行
这样的话我们会得到一个 O ( n m 4 ) O(nm^4) O(nm4)的算法,但是 n ≤ 200 n\leq200 n≤200我们至少要把他优化到 O ( n m 2 l o g ) O(nm^2log) O(nm2log)级别(当然这道题很明显不带 l o g log log)
这里我们看一下, I I I是一个什么样的结构,比如说我们设这3个矩形的左右端点分别是 [ l 1 , r 1 ] [l_1,r_1] [l1,r1], [ l 2 , r 2 ] [l_2,r_2] [l2,r2], [ l 3 , r 3 ] [l_3,r_3] [l3,r3](高度我们先不管他)
那么,为了满足 I I I字形的条件,中间那个矩形要比两边的都要窄,也就是说
l 1 < l 2 ≤ r 2 < r 1 , l 3 < l 2 ≤ r 2 < r 3 l_1
这也是在刚才 O ( n m 4 ) O(nm^4) O(nm4)的算法中转移时 x , y x,y x,y的要求
那么为了优化,我们可以记录一下之前在这些区间里的最大矩形的面积,所以我们开一个辅助数组
g [ j ] [ k ] [ l ] ( l = 1 , 2 ) g[j][k][l](l=1,2) g[j][k][l](l=1,2)
g [ j ] [ k ] [ 1 ] g[j][k][1] g[j][k][1]表示在上一行中,包含区间 [ j , k ] [j,k] [j,k]的最大面积
g [ j ] [ k ] [ 2 ] g[j][k][2] g[j][k][2]表示,在上一行中,被区间 [ j , k ] [j,k] [j,k]包含的最大面积
我们看一下为什么这样可以减少复杂度
在由第一个矩阵转向第二个矩阵的时候,我们之前循环的 x , y x,y x,y一定是要完全包含第二个矩阵的,那么我们在第二个矩阵循环 x , y x,y x,y的时候,就可以直接通过调用 g g g数组来避免循环 x , y x,y x,y
比如对于区间 [ l 2 , r 2 ] [l_2,r_2] [l2,r2]他的上一个最大的满足条件的就是 g [ l 2 − 1 ] [ r 2 + 1 ] [ 1 ] g[l_2-1][r_2+1][1] g[l2−1][r2+1][1],为什么要两边都增加一个呢?因为我们定义 g g g数组的时候定义的是闭区间,但是这里要求的是开区间(因为两边都不能相等)
对于第三个矩阵向第二个矩阵转移的时候也是一样的
我们再来看看 g g g数组如何转移
很明显 g g g数组是由 f f f数组转移过来的,那么我们就可以得到一个转移方程
g [ j ] [ k ] [ 1 ] = m a x { f [ i ] [ j ] [ k ] [ 1 ] , g [ j − 1 ] [ k ] [ 1 ] , g [ j ] [ k + 1 ] [ 1 ] } g[j][k][1]=max\{f[i][j][k][1],g[j-1][k][1],g[j][k+1][1]\} g[j][k][1]=max{f[i][j][k][1],g[j−1][k][1],g[j][k+1][1]}
首先,包含区间 [ j , k ] [j,k] [j,k]的可以是它本身,即 f [ i ] [ j ] [ k ] [ 1 ] f[i][j][k][1] f[i][j][k][1],也可以是它左右转移过来,但是必须包含,就是 g [ j − 1 ] [ k ] [ 1 ] g[j-1][k][1] g[j−1][k][1]和 g [ j ] [ k + 1 ] [ 1 ] g[j][k+1][1] g[j][k+1][1]这三种情况取个 m a x max max就可以了
对于第二个矩阵往第三个矩阵转移,其实是差不多的
g [ j ] [ k ] [ 2 ] = m a x { f [ i ] [ j ] [ k ] [ 2 ] , g [ j + 1 ] [ k ] [ 2 ] , g [ j ] [ k − 1 ] [ 2 ] } g[j][k][2]=max\{f[i][j][k][2],g[j+1][k][2],g[j][k-1][2]\} g[j][k][2]=max{f[i][j][k][2],g[j+1][k][2],g[j][k−1][2]}
初值
f , g f,g f,g都要赋成 − i n f -inf −inf,为什么不能是0呢?因为我们发现,第二个矩阵必需由第一个矩阵做完了才能轮到他,第三个必需要等第二个矩阵做完了,如果设成0的话我们就不知道他该不该做了
循环顺序
循环顺序要注意的地方主要是两个
一个是 l l l那一维,我们要从3到1循环,为什么呢?其实跟初值问题是一样的,如果先把1更新完了,g数组就不正确了,就是下一行的g数组了
还有一个就是 g g g数组的转移顺序,看他的转移方程,比如以第一个矩形到第二个矩形的为例
我们做 g [ j ] [ k ] [ 1 ] g[j][k][1] g[j][k][1]的时候,我们必须确保 g [ j − 1 ] [ k ] [ 1 ] g[j-1][k][1] g[j−1][k][1], g [ j ] [ k + 1 ] [ 1 ] g[j][k+1][1] g[j][k+1][1]都已知
所以我们需要让 j j j倒序循环, k k k正序循环
对于 g [ j ] [ k ] [ 2 ] g[j][k][2] g[j][k][2],反过来就可以啦
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
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;
}
虽然上面的代码已经可以在 b z o j bzoj bzoj上过了,但是空间复杂度并不是很优, b z o j bzoj bzoj上的空间限制是256mb,如果变成128就会被卡掉qwq
所以一个很好想的优化就出来了——滚动数组,我们可以把 f f f的 i i i那一维给滚掉
但是注意要每次做的时候要把当前行再赋一次初值 − i n f -inf −inf
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
# include
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
感谢gjm给我的这道题的解释
以及https://www.cnblogs.com/butterflydew/p/9372076.html——唯一一篇我看懂了的题解