2019牛客暑期多校训练营（第八场）补题

最新推荐文章于 2024-08-16 21:13:52 发布

原创最新推荐文章于 2024-08-16 21:13:52 发布 · 232 阅读

1 ·

CC 4.0 BY-SA版权

比赛补题专栏收录该内容

14 篇文章

订阅专栏

本文探讨了如何求解所有由1组成的子矩阵数量，确保每个子矩阵独立且不被其他矩阵完全包含。通过使用单调栈求解每行中1的高度边界，并结合前缀和进行去重检查，实现高效计算。

A题：

题目链接：https://ac.nowcoder.com/acm/contest/888/A

题意：求所有全为1的矩阵且每个子矩阵都不会被其他矩阵完全包含的子矩阵的个数。

分析：最近遇到的全1子矩阵的题有点多额....，可是还是不怎么会做。但基本都用了单调栈....

设h[i][j]表示第i行以j点为底点的最高连续的1的个数，可以用单调栈求使j点以h[i][j]为高度的矩形的左右边界(悬线法也可以)

然后，统计个数，此时就要去重了，相同的行去重可以通过单调栈来判断，每一行构造单调递增的栈，是否栈顶和h[i][j]相等，如果相等即为重复，不同的行去重是通过前缀和，判断第i行第j个点是否可以通过sum[i+1][R[j]]-sum[i+1][L[j]-1]!=R[j]-L[j]+1来判断，如果不等表示下一行从L[j]到R[j]不全是1，即第i行的那个矩阵不会被包含。

Ac code:

#include <bits/stdc++.h>
using namespace std;
const int maxn=3005;
typedef long long ll;
int a[maxn][maxn],L[maxn],R[maxn];
int sum[maxn][maxn],h[maxn][maxn];
stack<int>st;
int main()
{
    ios::sync_with_stdio(0),cin.tie(0);
    int n,m;
    cin>>n>>m;
    char x;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++){
            cin>>x,a[i][j]=x-'0';
            sum[i][j]=sum[i][j-1]+a[i][j];
            if(a[i][j]==1) h[i][j]=h[i-1][j]+1;
            else h[i][j]=0;
        }
    int ans=0;
    for(int i=1; i<=n; i++){
        while(!st.empty()) st.pop();
        st.push(0);
        for(int j=1;j<=m;j++)///单调栈求使j点以h[i][j]为高度的矩形的左右边界
        {
            while(!st.empty()&&h[i][j]<=h[i][st.top()])
                st.pop();
            if(st.empty()) L[j]=1;
            else L[j]=st.top()+1;
            st.push(j);
        }
        while(!st.empty()) st.pop();
        st.push(m+1);
        for(int j=m;j>=1;--j)
        {
            while(!st.empty()&&h[i][j]<=h[i][st.top()])
                st.pop();
            if(st.empty()) R[j]=m;
            else R[j]=st.top()-1;
            st.push(j);
        }
        while(!st.empty()) st.pop();
        for(int j=1; j<=m; j++)
        {
            if(!h[i][j]){
                while(!st.empty()) st.pop();
                continue;
            }
            while(!st.empty()&&h[i][j]<h[i][st.top()])
                st.pop();
            if(st.empty()||h[i][j]!=h[i][st.top()]){///同一行去重
                int l=L[j];
                int r=R[j];
                if(sum[i+1][r]-sum[i+1][l-1]!=r-l+1)///不同行去重
                    ++ans;
                st.push(j);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

类似的还有第四场的牛客C题：https://ac.nowcoder.com/acm/contest/884/C

也是用单调栈求出使a[i]最小的左右边界，然后维护前缀和的线段树而已。

Ac code:

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=3e6+2;
const ll INF=1e18;
struct Tree{
    ll _min,_max;
}tree[maxn<<2];
ll pre[maxn];
int L[maxn],R[maxn],n,a[maxn],b[maxn];
stack<int>s;
void init()
{
    for(int i=1;i<=n;i++)///单调栈求使a[i]成为最小值的左右边界L[i],R[i]
    {
        if(s.empty())
            s.push(i);
        else{
            while(!s.empty()&&a[s.top()]>a[i])
            {
                R[s.top()]=i;
                s.pop();
            }
            s.push(i);
        }
    }
    while(!s.empty()) R[s.top()]=n+1,s.pop();
    for(int i=n;i>=1;i--)
    {
        if(s.empty())
            s.push(i);
        else{
            while(!s.empty()&&a[s.top()]>a[i])
            {
                L[s.top()]=i;
                s.pop();
            }
            s.push(i);
        }
    }
    while(!s.empty()) L[s.top()]=0,s.pop();
}
void pushup(int rt)
{
    tree[rt]._min=min(tree[rt<<1]._min,tree[rt<<1|1]._min);
    tree[rt]._max=max(tree[rt<<1]._max,tree[rt<<1|1]._max);
}
void buildtree(int rt,int l,int r)
{
    if(l==r){
        tree[rt]._max=pre[l];
        tree[rt]._min=pre[l];
        return;
    }
    int mid=(l+r)>>1;
    buildtree(rt<<1,l,mid);
    buildtree(rt<<1|1,mid+1,r);
    pushup(rt);
}
ll query(int rt,int l,int r,int L,int R,bool flag)///flag=1查最大
{
    if(R<l||L>r) return 0;
    if(L<=l&&r<=R){
        if(flag) return tree[rt]._max;
        else return tree[rt]._min;
    }
    int mid=(l+r)>>1;
    if(flag){
        ll ans=-INF;
        if(mid>=L) ans=max(ans,query(rt<<1,l,mid,L,R,flag));
        if(mid<R) ans=max(ans,query(rt<<1|1,mid+1,r,L,R,flag));
        return ans;
    }
    else{
        ll ans=INF;
        if(mid>=L) ans=min(ans,query(rt<<1,l,mid,L,R,flag));
        if(mid<R) ans=min(ans,query(rt<<1|1,mid+1,r,L,R,flag));
        return ans;
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=n;i++) scanf("%d",&b[i]),pre[i]=pre[i-1]+b[i];
    init();
    buildtree(1,1,n);
    ll ans=-INF;
    for(int i=1;i<=n;i++)
    {
        if(a[i]>=0)///a[i]>=0故要使区间和最大,即后面的最大减前面的最小才可最大
            ans=max(ans,1ll*a[i]*(query(1,1,n,i,R[i]-1,1)-query(1,1,n,L[i],i-1,0)));
        else///反之亦然
            ans=max(ans,1ll*a[i]*(query(1,1,n,i,R[i]-1,0)-query(1,1,n,L[i],i-1,1)));
    }
    printf("%lld\n",ans);
    return 0;
}

最后贴一个大佬的全01子矩阵计数的博客：https://blog.youkuaiyun.com/Z_sea/article/details/90258312