极大化思想/悬线法题集

用于解决最大子矩阵问题

---

P1387 最大正方形

题意：

在一个n*m的只包含0和1的矩阵里找出一个不包含0的最大正方形，输出边长。

数据范围：n,m<=100

解法：

悬线法计算出每个点左右上三个方向的最大扩展距离距离，min(r-l+1,h)就是当前点所在极大正方形的边长
对所有极大正方形边长取max就是答案

code：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=105;
int a[N][N];
int l[N][N];
int r[N][N];
int h[N][N];
int n,m;
signed main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>a[i][j];
            //init
            l[i][j]=r[i][j]=j;
            h[i][j]=1;
            //
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=2;j<=m;j++){
            if(a[i][j]&&a[i][j-1]){
                l[i][j]=l[i][j-1];
            }
        }
        for(int j=m-1;j>=1;j--){
            if(a[i][j]&&a[i][j+1]){
                r[i][j]=r[i][j+1];
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(i>=2&&a[i][j]&&a[i-1][j]){
                l[i][j]=max(l[i][j],l[i-1][j]);
                r[i][j]=min(r[i][j],r[i-1][j]);
                h[i][j]=h[i-1][j]+1;
            }
            ans=max(ans,min(r[i][j]-l[i][j]+1,h[i][j]));
        }
    }
    cout<<ans<<endl;
    return 0;
}

---

P1169 [ZJOI2007]棋盘制作

题意：

给定n*m的01矩阵，要求计算满足条件的最大正方形和最大长方形的面积（长方形包括正方形）
条件：相邻格子不同，即矩阵中的0和1交叉

数据范围：n,m<=2e3

解法：

将扩展条件修改为相邻格子不同即可

注意一下边界，偷懒不写的话不小心就让a(1,k)和a(0,k)匹配了

code：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=2e3+5;
int a[N][N];
int l[N][N];
int r[N][N];
int h[N][N];
int n,m;
signed main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>a[i][j];
            l[i][j]=r[i][j]=j;
            h[i][j]=1;
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=2;j<=m;j++){
            if(a[i][j]!=a[i][j-1]){
                l[i][j]=l[i][j-1];
            }
        }
        for(int j=m-1;j>=1;j--){
            if(a[i][j]!=a[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>=2&&a[i][j]!=a[i-1][j]){//注意这里要i>=2,否则可能匹配到a[0]
                h[i][j]=h[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]);
            }
            ans1=max(ans1,min(r[i][j]-l[i][j]+1,h[i][j])*min(r[i][j]-l[i][j]+1,h[i][j]));
            ans2=max(ans2,(r[i][j]-l[i][j]+1)*h[i][j]);
        }
    }
    cout<<ans1<<endl<<ans2<<endl;
    return 0;
}

---

P1578 奶牛浴场

题意：

给定长度为R*C的矩阵，里面有N个障碍点，求不包含障碍点的最大子矩阵

数据范围：R,C<=3e4，N<=5e3

解法：

这题题目的坐标系是以左下角为(0,0)，右上角为(R,C)的平面直角坐标系

因为矩阵太大，开不下悬线法所需要的几个数组，所以没办法用悬线法。
但是障碍点的最大数量是给定的，只有5e3，比较小，因此可以利用极大化思想O(N²)解决问题。
基本思路是通过枚举障碍点来获得所有极大子矩阵
1.一种情况是先对障碍点按横坐标排序，两层循环枚举障碍点作为左右边界，并按照两枚举点间的其他障碍点纵坐标修改上下边界。
例如：
初始图：

枚举左边界为1，右边界为2：

右边界从2枚举到3，那么下边界需要修改为2的纵坐标

以此类推，主要原理是极大子矩阵内不能存在障碍点，因此上下边界会不断缩小

2.一种情况是矩形整体的左右边框作为左右边界，这时候对障碍点按纵坐标y排序，这种情况下每个极大子矩阵的面积是：相邻障碍点纵坐标差*矩形左右边界距离
如下图中的灰色部分：

对上述两种情况计算出的所有极大子矩阵的面积取max就是答案

ps：
极大化思想解法复杂度为O(障碍点数²)
悬线法复杂度是O(矩阵长*矩阵宽)

code：

#include<bits/stdc++.h>
using namespace std;
//#define int long long
const int N=3e4+5;
struct Node{
    int x,y;
}a[N];
bool cmp(Node a,Node b){//按横坐标从小到大排序
    if(a.x!=b.x)return a.x<b.x;
    return a.y<b.y;
}
bool cmp2(Node a,Node b){//按纵坐标从小到大排序
    return a.y<b.y;
}
signed main(){
    int R,C;
    scanf("%d%d",&R,&C);
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&a[i].x,&a[i].y);
    }
    //将整个大矩形的四个端点加入,视为障碍点
    a[++n]={0,0};//
    a[++n]={0,C};
    a[++n]={R,0};
    a[++n]={R,C};
    //
    sort(a+1,a+1+n,cmp);
    //左上角为(0,0),右下角为(R,C)
    int ans=0;
    for(int i=1;i<=n;i++){//枚举一个边界
        int up=C,down=0;
        for(int j=i+1;j<=n;j++){//从左往右枚举右边界
            ans=max(ans,(a[j].x-a[i].x)*(up-down));
            if(a[j].y>a[i].y)up=min(up,a[j].y);
            else down=max(down,a[j].y);
        }
    }
//    for(int i=1;i<=n;i++){//实测把从右往左扫描的这一段注释掉也能ac!?
//        int up=C,down=0;
//        for(int j=i-1;j>=1;j--){//从右往左枚举左边界
//            ans=max(ans,(a[i].x-a[j].x)*(up-down));
//            if(a[j].y>a[i].y)up=min(up,a[j].y);
//            else down=max(down,a[j].y);
//        }
//    }
    sort(a+1,a+1+n,cmp2);
    for(int i=2;i<=n;i++){
        ans=max(ans,(a[i].y-a[i-1].y)*C);
    }
    printf("%d\n",ans);
    return 0;
}

---