[CTSC2002] 颁奖典礼

最新推荐文章于 2022-01-11 16:43:06 发布

NephrenRuqInsania

最新推荐文章于 2022-01-11 16:43:06 发布

阅读量1.4k

点赞数 1

分类专栏： # 线性dp&多维dp

本文链接：https://blog.csdn.net/devout_/article/details/104208178

版权

线性dp&多维dp 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

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

因为我太菜了，网上其他的有关于这道题的博客~~全都看不懂~~
而且写博客的人都比较巨，比如说 $k a i s e r$ 神仙（orz您）
后来我在 $a k i o i$ 的 $g j m$ 的帮助下理解了这道题（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，我们可以开一个数组 $s u m [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)$ 级别（当然这道题很明显不带 $l o g$ ）

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]$ 这三种情况取个 $m a x$ 就可以了

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

2.3 初值与循环顺序

初值
$f, g$ 都要赋成 $- i n f$ ，为什么不能是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.空间优化

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

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

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

# 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;
}