子矩阵的种种做法

最新推荐文章于 2023-04-17 16:43:12 发布

Demon_Rieman

最新推荐文章于 2023-04-17 16:43:12 发布

阅读量2k

点赞数

分类专栏：优化考试题解文章标签：优化子矩阵二维数组

本文链接：https://blog.csdn.net/Demon_Rieman/article/details/78370009

版权

优化同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

考试题解

6 篇文章 0 订阅

订阅专栏

前言：

信息学竞赛中，会遇到一些问题，即给出一个矩阵（二维数组），求满足某个条件的子矩阵的个数，或是满足某个条件的最大，最小子矩阵之类的问题，在这里我总结一小点，防止以后再遭套路。

常用方法：

枚举子矩阵左上点，右下点（ $O(n^4)$ ）。

常用优化：

（1）如果子矩阵内的条件只与其本身有关，而与其他没被选的有关，那么可以用前缀和优化。（比如要求子矩阵内的和之类的）。这样，可以把判定条件从 $n^2$ 优化到 $1$ 。
（2）如果子矩阵本身有特殊性（题上说的或推出来的），那么枚举子矩阵时一般可以少一个 $n$ （比如子矩阵是正方形，就只用枚举对角线就可以了）。
（3）条件具有单调性，那么就可以用个单调队列或者尺取法之类的优化。
（4）与值有关的，也许还可以记一个桶，然后用组合计数统计答案。

例题：

- T1

给定一个矩阵，其位置上的值只能是 $0$ 或 $1$ ，求最大的正方形使得这个正方形边界及其内部全是 $1$ 。

分析：

Ⅰ） $O（n^3）$ 做法：
首先，前缀和优化一下，然后枚举正方形的左上端点，那么然后再以此对角线枚举右下一个端点。这样是 $n^3$ 的。

Ⅱ） $O（n^2logn）$ 做法：
明显如果左上端点确定了，那么对于一个大正方形如果都满足，那么小一些的也一定成立，这样就可以二分一下。
Ⅲ） $O（n^2）$ 做法：
我们发现，如果一个正方形满足条件，那么其在右下端点向上，向左看，都有连续的一段1，那么我们可以储存一下这个连续的段，就可以边读边做。
代码：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <bitset>
#include <cmath>
#include <map>
using namespace std;
const int N = 2000 + 5;
int n,m,ans,mp[N][N],sum[N][N];
int read() {
    int x = 0, f = 1;char ch = getchar();
    while( ch <  '0' || ch >  '9'){ if( ch == '-' ) f = -1; ch = getchar(); }
    while( ch >= '0' && ch <= '9'){ x = x*10+ch-'0'; ch = getchar(); }
    return x * f;
}
int main(){
    n = read(); m = read();
    for( int i = 1; i <= n; i++ )
        for( int j = 1; j <= m; j++ )
            mp[i][j] = read();
    for( int i = 1; i <= n; i++ )
        for( int j = 1; j <= m; j++ )
            sum[i][j] = mp[i][j]+sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1];
    for( int i = 1; i <= n; i++ )
        for( int j = 1; j <= m; j++ ){
            if( !mp[i][j] ) continue; bool flag = 0;
            while( ans <= i && ans <= j && sum[i][j]-sum[i-ans][j]-sum[i][j-ans]+sum[i-ans][j-ans] == ans*ans ) ans++, flag = 1;
            if( flag ) ans--;
        }
    printf("%d\n", ans);
    return 0;
}

- T2

给定一个矩阵，其位置上的值只能是0或1，求有多少个子矩阵中的1个数（实际上是要满足条件的1的个数，但这不是重点）大于等于给定k。

分析：

这道题要好好说一下：如何从 $n^6$ 优化到 $n^3$ 。
Ⅰ）最暴力的搞法：
枚举左上的点，右下的点，再 $n^2$ 算出其中的 $1$ 的个数。（ $n^6$ ）
Ⅱ）优化很多的做法：
拿一个二位前缀和，就可以把算出 $1$ 的个数那一步从 $n^2$ 优化到 $1$ 。此时总·复杂度 $n^4$ 。
Ⅲ）继续优化：
注意到当（左上节点）以及（右下的节点横或纵坐标）确定时，矩形越大，那么包含的 $1$ 的个数就是不降的，然后就可以用这个性质二分。此时复杂度 $n^3logn$ 。
Ⅳ）最终优化：
既然都有这样的单调性，那么我们先枚举矩形的左右边界，然后枚举上下边界，如果下边界在 $k$ 时满足了条件，那么在 $k+1$ ， $n$ 也会满足条件，就不用继续枚举了，此时可以把上边界向下移动了，做下一个上边界时，下边界直接从之前的下边界开始枚举。实际就是尺取，此时复杂度 $n^3$ 。很难再优化了。
代码：

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int size = 505; 
ll mat[size][size];
char pre[size][size];
ll n , m , k;
ll ans = 0;

ll calc(ll x1,ll y1,ll x2,ll y2)
{ return (mat[x2][y2]+mat[x1-1][y1-1]-mat[x1-1][y2]-mat[x2][y1-1]); }

int main()
{
    scanf("%lld%lld%lld",&n,&m,&k);
    for (int i = 1 ; i <= n ; i++)
    scanf("%s" , pre[i]);               
    for (int i = 1;i <= n ;i++)
    for (int j = 0;j <  m ;j++)
    mat[i][j+1] = mat[i-1][j + 1] + mat[i][j] - mat[i-1][j] + 
    ( pre[i][j] == '*' && pre[i+1][j] == '*' && pre[i-1][j] == '*' && pre[i][j+1] =='*' && pre[i][j-1] =='*');      
    for (int l = 1; l <= m;l++)
      for (int r = l + 2;r <= m;r++)
      {
        int up = 1 , down = 3;
        for (up;up<=n;up++)
        {
            while (calc(up+1,l+1,down-1,r-1) < k && down<=n) ++down;
            if (down==n+1) break;
            ans += n - down + 1 ;           
        }
      }
    printf("%lld",ans); 
    return  0;
}

- T3

给定一个矩阵，位置上是整数，求有多少个子矩阵的内部和为 $k$ 的倍数。

分析：

Ⅰ）暴力加前缀和优化（不说了）。 $n^4$ 。
Ⅱ）类似之前的尺取，我们固定矩形的上下边界，然后扫描一下每一列的和，记一个桶，然后根据桶的个数算组合数，即模 $k$ 为 $i$ 的与 $k-i$ 的配成一对。注意这样子的话，本身就是k的倍数的数要特殊处理一下，因为它是单独都可以满足条件的。（可以参照代码，在 $0$ 号桶提前加一个 $1$ ）。还有就是这个桶还原时不要 $memset$ ，要 $tle$ ，还不如一个一个还原。
代码：

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int size =  502;
bool check = true;
int a[size][size];
int mat[size][size],n,m,k,tong[1000002]={1};
ll ans=0;
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
    scanf("%d",&a[i][j]);
    for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
    mat[i][j] = (mat[i-1][j] + mat[i][j-1] - mat[i-1][j-1] + a[i][j] )%k;

    for (int x1=1;x1<=n;x1++)
    for (int x2=x1;x2<=n;x2++)
    {
        for (int y=1;y<=m;y++)  ans += tong[(mat[x2][y] - mat[x1-1][y] + 2*k ) % k]++;
        for (int y=1;y<=m;y++)  tong[(mat[x2][y] - mat[x1-1][y] + 2*k ) % k]--;
    }
    printf("%lld",ans);
}