NC20471 [ZJOI2007]棋盘制作

题目链接

题目

题目描述

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

据说国际象棋起源于易经的思想，棋盘是一个8*8大小的黑白相间的方阵，对应八八六十四卦，黑白对应阴阳。

而我们的主人公小Q，正是国际象棋的狂热爱好者。作为一个顶尖高手，他已不满足于普通的棋盘与规则，于是他跟他的好朋友小W决定将棋盘扩大以适应他们的新规则。

小Q找到了一张由N*M个正方形的格子组成的矩形纸片，每个格子被涂有黑白两种颜色之一。小Q想在这种纸中裁减一部分作为新棋盘，当然，他希望这个棋盘尽可能的大。

不过小Q还没有决定是找一个正方形的棋盘还是一个矩形的棋盘（当然，不管哪种，棋盘必须都黑白相间，即相邻的格子不同色），所以他希望可以找到最大的正方形棋盘面积和最大的矩形棋盘面积，从而决定哪个更好一些。于是小Q找到了即将参加全国信息学竞赛的你，你能帮助他么？

输入描述

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

输出描述

包含两行，每行包含一个整数。
第一行为可以找到的最大正方形棋盘的面积，
第二行为可以找到的最大矩形棋盘的面积（注意正方形和矩形是可以相交或者包含的）。

示例1

输入

3 3
1 0 1
0 1 0
1 0 0

输出

4
6

备注

对于20%的数据，N, M ≤ 80

对于40%的数据，N, M ≤ 400

对于100%的数据，N, M ≤ 2000

题解

方法一

知识点：线性dp，悬线法。

悬线法：

1. 每个点都有独立左右延长的最大宽度。

2. 每个点都有一个往上延长的最大高度，但最大宽度会被其他点的最大宽度限制。也就是说，这个点的高度经过的所有点的最大宽度的最小值是实际这个点的最大宽度。

3. 对一个点先延长其高度，在取高度经过点的最大宽度的最小值，可以得到这个点的高度最大的最大矩形。

4. 由于最大矩形一定是某个点的最大高度，及其高度经过点的最大宽度的最小值构成，所以通过这个方法一定能找到。证明如下：

   假设矩形的所有底部点的最大高度比这个矩形的高度都大，那么显然我们可以把这个矩形的高度往上延长直到这些点最大高度的最小值而不会改变宽度，可以使得矩形更大，因此最大矩形的高度一定是某个点的最大高度。那么在一个高度限制下，一定是宽度最大的矩形更大。综上，对所有点优先延长其高度，然后再是左右扩展。

5. 要注意的是，高度，左延长，右延长，三个量一个都不能少。少了高度算不出，少了左右的一个会少算矩形，因为没有左右的传递性，左侧的最大矩形，并不一定是右侧的最大矩形，遍历到右边也许不是同一个矩形了，所以都要算。

这道题是悬线法的运用。

先预处理出每个点的左右延展的最远位置，初始化高度为 $1$ 。

然后开始向下遍历，逐行更新。可以看到在这个规则下，也是可以满足悬线法要求的，即 1，2，3的要求（宽度不会随高度变化）。

具体细节看代码更清楚。

时间复杂度 $O(nm)$

空间复杂度 $O(nm)$

方法二

知识点：线性dp，单调栈。

悬线法能解决的问题是单调栈的子集。

这道题也能用单调栈做，只要以行为底线遍历计算最大矩形即可，先处理一行的每个点的最大高度，然后和单调栈那道直方图的题一样处理。

当然要注意每行可能有若干条底线。

时间复杂度 $O(nm)$

空间复杂度 $O(nm)$

代码

方法一

#include <bits/stdc++.h>
 
using namespace std;
 
bool dt[2007][2007];
int l[2007][2007], r[2007][2007], u[2007][2007];///有且仅有三个即可
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= n;i++)
        for (int j = 1;j <= m;j++)
            cin >> dt[i][j], l[i][j] = r[i][j] = j, u[i][j] = 1;
    for (int i = 1;i <= n;i++)///水平左最长
        for (int j = 2;j <= m;j++)
            if (dt[i][j - 1] != dt[i][j]) l[i][j] = l[i][j - 1];
    for (int i = 1;i <= n;i++)///水平右最长
        for (int j = m - 1;j >= 1;j--)
            if (dt[i][j] != dt[i][j + 1]) r[i][j] = r[i][j + 1];
    int ans1 = 0, ans2 = 0;
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) {
            if (i > 1 && dt[i - 1][j] != dt[i][j]) {///高度优先的向下传递更新
                u[i][j] = u[i - 1][j] + 1;
                l[i][j] = max(l[i][j], l[i - 1][j]);
                r[i][j] = min(r[i][j], r[i - 1][j]);
            }
            int a = r[i][j] - l[i][j] + 1;
            ans1 = max(ans1, min(a, u[i][j]) * min(a, u[i][j]));
            ans2 = max(ans2, a * u[i][j]);
        }
    }
    cout << ans1 << '\n' << ans2 << '\n';
    return 0;
}

方法二

#include <bits/stdc++.h>
 
using namespace std;
 
bool dt[2007][2007];
int l[2007], r[2007], u[2007];
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= n;i++)
        for (int j = 1;j <= m;j++)
            cin >> dt[i][j];
    int ans1 = 0, ans2 = 0;
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) {
            if (i > 1 && dt[i - 1][j] != dt[i][j]) u[j]++;
            else u[j] = 1;
        }
        for (int j = 1;j <= m;j++) {
            stack<int> s;
            int k;
            ///不必再考虑上一层同列的扩展长度取最小值
            ///因为如果这层底部能扩展，则说明底部元素不同，则同一高度元素一定不同
            ///因此长度和高度是相匹配的，不需要考虑上一次长度
            for (k = j;k <= m && (k == j || dt[i][k - 1] != dt[i][k]);k++) {
                while (!s.empty() && u[k] <= u[s.top()]) s.pop();
                l[k] = s.empty() ? j : s.top() + 1;///是有效位置前一个的位置，记得+1
                s.push(k);
            }
            j = k - 1;
        }
        for (int j = m;j >= 1;j--) {
            stack<int> s;
            int k;
            for (k = j;k >= 1 && (k == j || dt[i][k] != dt[i][k + 1]);k--) {
                while (!s.empty() && u[k] <= u[s.top()]) s.pop();
                r[k] = s.empty() ? j : s.top() - 1;///同上
                s.push(k);
            }
            j = k + 1;
        }
        for (int j = 1;j <= m;j++) {
            int a = r[j] - l[j] + 1;
            ans1 = max(ans1, min(a, u[j]) * min(a, u[j]));
            ans2 = max(ans2, a * u[j]);
        }
    }
    cout << ans1 << '\n' << ans2 << '\n';
    return 0;
}