BZOJ1057 [ZJOI2007]棋盘制作【最大同色矩形】

1057: [ZJOI2007]棋盘制作

Time Limit: 20 Sec Memory Limit: 162 MB

Submit: 3248 Solved: 1636

[Submit][Status][Discuss]

Description

　　国际象棋是世界上最古老的博弈游戏之一，和中国的围棋、象棋以及日本的将棋同享盛名。据说国际象棋起源

于易经的思想，棋盘是一个8*8大小的黑白相间的方阵，对应八八六十四卦，黑白对应阴阳。而我们的主人公小Q，

正是国际象棋的狂热爱好者。作为一个顶尖高手，他已不满足于普通的棋盘与规则，于是他跟他的好朋友小W决定

将棋盘扩大以适应他们的新规则。小Q找到了一张由N*M个正方形的格子组成的矩形纸片，每个格子被涂有黑白两种

颜色之一。小Q想在这种纸中裁减一部分作为新棋盘，当然，他希望这个棋盘尽可能的大。不过小Q还没有决定是找

一个正方形的棋盘还是一个矩形的棋盘（当然，不管哪种，棋盘必须都黑白相间，即相邻的格子不同色），所以他

希望可以找到最大的正方形棋盘面积和最大的矩形棋盘面积，从而决定哪个更好一些。于是小Q找到了即将参加全

国信息学竞赛的你，你能帮助他么？

Input

　　第一行包含两个整数N和M，分别表示矩形纸片的长和宽。接下来的N行包含一个N * M的01矩阵，表示这张矩形

纸片的颜色（0表示白色，1表示黑色）。

Output

　　包含两行，每行包含一个整数。第一行为可以找到的最大正方形棋盘的面积，第二行为可以找到的最大矩形棋

盘的面积（注意正方形和矩形是可以相交或者包含的）。

Sample Input

3 3

1 0 1

0 1 0

1 0 0

Sample Output

4

6

HINT

N, M ≤ 2000

好像以前写过？

再写一遍加深印象

开一个sum[i][j]表示位置(i,j)能向右同色延伸的最大长度

我们先定下矩形的左边所在列，对该列中的点按向右延伸长度降序排序，然后枚举每个点

这样子每次枚举出的点对应的宽一定是当前最小的【宽】，再用并查集维护其向上向下最长延伸距离【长】，

我们就可以得出以该点为向右为宽的最大矩形面积

而我们最后求出的矩形的宽一定会受其中至少一个点向右延伸长度的束缚

当我们枚举到答案中影响宽的那一个点的时候就一定能更新出最优答案

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#define LL long long int

#define REP(i,n) for (int i = 1; i <= (n); i++)

#define Redge(u) for (int k = head[u]; k != -1; k = edge[k].next)

using namespace std;

const int maxn = 2005,maxm = 100005,INF = 1000000000;

inline int RD(){

	int out = 0,flag = 1; char c = getchar();

	while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}

	while (c >= 48 && c <= 57) {out = (out << 1) + (out << 3) + c - '0'; c = getchar();}

	return out * flag;

}

int A[maxn][maxn],sum[maxn][maxn],N,M,up[maxn],down[maxn],ans1 = 0,ans2 = 0;

bool vis[maxn];

struct node{int i,len;}e[maxn];

inline bool operator < (const node& a,const node& b){return a.len > b.len;}

inline int findu(int u){return u == up[u] ? u : up[u] = findu(up[u]);}

inline int findd(int u){return u == down[u] ? u : down[u] = findd(down[u]);}

void solve(){

	for (int i = 1; i <= N; i++){

		sum[i][M] = 1;

		for (int j = M - 1; j > 0; j--)

			sum[i][j] = A[i][j] == A[i][j + 1] ? sum[i][j + 1] + 1 : 1;

	}

	for (int j = 1; j <= M; j++){

		for (int i = 1; i <= N; i++){

			e[i].i = i; e[i].len = sum[i][j]; down[i] = up[i] = i; vis[i] = false;

		}

		sort(e + 1,e + 1 + N);

		for (int i = 1; i <= N; i++){

			int k = e[i].i; vis[k] = true;

			//printf("(%d,%d)  len = %d   %d\n",k,j,e[i].len,ans1);

			if (k > 1 && vis[k - 1] && A[k - 1][j] == A[k][j]){

				up[k] = findu(k - 1);

				down[k - 1] = k;

			}

			if (k < N && vis[k + 1] && A[k + 1][j] == A[k][j]){

				down[k] = findd(k + 1);

				up[k + 1] = k;

			}

			int u = findu(k),d = findd(k),ed = min(e[i].len,d - u + 1);

			//printf("%d %d\n",u,d);

			ans1 = max(ans1,ed * ed);

			ans2 = max(ans2,e[i].len * (d - u + 1));

		}

	}

}

int main(){

	N = RD(); M = RD();

	REP(i,N) REP(j,M) A[i][j] = RD() ^ ((i & 1) ^ (j & 1));

	//REP(i,N){REP(j,M) cout<<A[i][j]<<' ';cout<<endl;}

	solve();

	cout<<ans1<<endl<<ans2<<endl;

	return 0;

}