[GXOI/GZOI2019]与或和[单调栈]

也许更好的阅读体验

\(\mathcal{Description}\)

给出一个 \(n\times n\) 的, 元素为自然数的矩阵.
这个矩阵有许许多多个子矩阵, 定义它的所有子矩阵形成的集合为 \(S\) .
对于一个矩阵 \(k\) , 定义 \(f (k)\) 为 \(k\) 中所有元素的 \(AND\) 值 (按位与).
对于一个矩阵 \(k\) , 定义 \(g(k)\) 为 \(k\) 中所有元素的 \(OR\) 值 (按位或).
请求出所有子矩阵的 \(f (k)\) 之和与所有子矩阵的 \(g(k)\) 之和, 即 \(\begin{aligned}\sum_{k\in S} f (k)\end{aligned}\) 与 \(\begin{aligned}\sum_{k\in S} g (k)\end{aligned}\)
由于答案可能很大, 只需要输出答案对\(1e9+7\)取模的结果.

\(n\leq1000,\)矩阵中每个元素大小在\(int\)范围内

\(\mathcal{Solution}\)

对于有位运算操作的题目,计算贡献时首先考虑的方法就是按位计算贡献
因为某一位的贡献是不会受到其他位影响的,而整体计算因为位运算的特殊性,还是会考虑到按位计算

我们枚举每一位\(k\),然后把矩阵换成\(0/1\)矩阵,其中\(0\)元素表示原本矩阵中这一元素在枚举到的这位二进制表示下为\(0\),为\(1\)则为\(1\)
考虑这个\(0/1\)矩阵中有多少个子矩阵会被计算贡献,最后把这个数乘以\(2^k\)

对于与运算,就是要求里面有多少个全\(1\)矩阵
对于或运算,就是要求里面有多少个有\(1\)矩阵

与运算和或运算实际上可以互相转换
全\(1\)矩阵数=所有矩阵数-有\(0\)矩阵数
有\(1\)矩阵数=所有矩阵数-全\(0\)矩阵数

设\(all\)为\(n\times n\)的矩阵所包含的所有子矩阵
显然\(all=(\frac{n(n+1)}{2})^2\)

之后考虑怎么计算满足条件的矩阵个数

\(55\)分解法 \(O(log_2n\cdot n^3)\)
考虑枚举矩阵的上边界,下边界
我们计算在这样的矩阵中满足要求的个数
有\(1\)矩阵显然容易做些
考虑枚举以一个矩阵中最左边的\(1\)出现位置
这样可以不重不漏全部计算
显然,只要包含了这个有\(1\)的一列,当前范围内所有矩阵都是合法的
注意不要和上一个有\(1\)的那列重复了

用\(sum[i][j]\)表示第\(j\)列到第\(i\)个位置共有多少\(1\)
只要\(sum[下边界][当前列]-sum[上边界-1][当前列]>0\)就说明这一列有\(1\)
其他的很简单,具体的过会儿看代码吧

\(100\)分解法 \(O(log_2n\cdot n^2)\)

考虑枚举矩阵的下边界
计算全\(1\)矩阵
用\(f[i][j]\)表示第\(j\)列,从\(i\)开始往上有多少个连续的\(1\)
然后枚举到哪一列了,用\(cnt\)表示每次会增加多少个矩阵
用单调栈维护一下即可

\(\mathcal{Code}\)

\(55\)分
试图卡常碰运气版

/*******************************
Author:Morning_Glory
LANG:C++
Created Time:2019年09月10日 星期二 14时17分44秒
*******************************/
#include <cstdio>
#include <fstream>
#include <algorithm>
#define rint register int
using namespace std;
const int maxn = 1003;
const int mod = 1000000007;
//{{{cin
struct IO{
    template<typename T>
    IO & operator>>(T&res){
        res=0;
        bool flag=false;
        char ch;
        while((ch=getchar())>'9'||ch<'0')   flag|=ch=='-';
        while(ch>='0'&&ch<='9') res=(res<<1)+(res<<3)+(ch^'0'),ch=getchar();
        if (flag)   res=~res+1;
        return *this;
    }
}cin;
//}}}
int n,mx,all,ans1,ans2;
int lt[maxn],up[maxn];
int a[maxn][maxn],sum[maxn][maxn];
bool hav[maxn];
bool b[maxn][maxn];
//{{{calc
inline int calc (int mi,bool opt)
{
    int res=0;
    for (rint i=1;i<=n;++i)
        for (int j=1;j<=n;++j){
            b[i][j]=(a[i][j]&mi);
            b[i][j]^=opt;
            sum[i][j]=sum[i-1][j]+b[i][j];
        }
    for (rint i=1;i<=n;++i)//上边界
        for (rint j=i;j<=n;++j){//下边界
            int last=0;
            for (rint k=1;k<=n;++k)//第一个1
                if (sum[j][k]-sum[i-1][k])  res=(res+(k-last)*(n-k+1))%mod,last=k;
        }
    return res;
}
//}}}
int main()
{
    cin>>n;
    for (rint i=1;i<=n;++i)
        for (rint j=1;j<=n;++j)
            cin>>a[i][j],mx=max(mx,a[i][j]);
    all=n*(n+1)/2%mod;
    all=1ll*all*all%mod;
    for (rint k=0;k<=31;++k){
        int t=1<<k;
        if (t>mx)   break;
        int num=calc(t,1);
        num=(all-num+mod)%mod;
        ans1=(ans1+1ll*num*t%mod)%mod;
        num=calc(1<<k,0);
        ans2=(ans2+1ll*num*t%mod)%mod;
    }
    printf("%d %d\n",ans1,ans2);
    return 0;
}

\(100\)分

/*******************************
Author:Morning_Glory
LANG:C++
Created Time:2019年09月10日 星期二 14时17分44秒
*******************************/
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn = 1003;
const int mod = 1000000007;
//{{{cin
struct IO{
    template<typename T>
    IO & operator>>(T&res){
        res=0;
        bool flag=false;
        char ch;
        while((ch=getchar())>'9'||ch<'0')   flag|=ch=='-';
        while(ch>='0'&&ch<='9') res=(res<<1)+(res<<3)+(ch^'0'),ch=getchar();
        if (flag)   res=~res+1;
        return *this;
    }
}cin;
//}}}
int n,mx,all,ans1,ans2;
int stk[maxn];
int a[maxn][maxn],f[maxn][maxn];
bool b[maxn][maxn];
//{{{calc
inline int calc (int mi,bool opt)
{
    int res=0;
    for (int i=1;i<=n;++i)
        for (int j=1;j<=n;++j){
            b[i][j]=(a[i][j]&mi);
            b[i][j]^=opt;
            f[i][j]=b[i][j]?f[i-1][j]+1:0;
        }
    for (int i=1;i<=n;++i){
        int cnt=0,top=0;
        for (int j=1;j<=n;++j){
            cnt+=f[i][j];
            while (top&&f[i][stk[top]]>f[i][j]) cnt-=(stk[top]-stk[top-1])*(f[i][stk[top]]-f[i][j]),--top;
            res=(res+cnt)%mod;
            stk[++top]=j;
        }
    }
    return res;
}
//}}}
int main()
{
    cin>>n;
    for (int i=1;i<=n;++i)
        for (int j=1;j<=n;++j)
            cin>>a[i][j],mx=max(mx,a[i][j]);
    all=n*(n+1)/2%mod;
    all=1ll*all*all%mod;
    for (int k=0;k<=31;++k){
        int t=1<<k;
        if (t>mx)   break;
        int num=calc(t,0);
        ans1=(ans1+1ll*num*t%mod)%mod;
        num=calc(1<<k,1);
        num=(all-num+mod)%mod;
        ans2=(ans2+1ll*num*t%mod)%mod;
    }
    printf("%d %d\n",ans1,ans2);
    return 0;
}

如有哪里讲得不是很明白或是有错误,欢迎指正
如您喜欢的话不妨点个赞收藏一下吧

原文地址:https://www.cnblogs.com/Morning-Glory/p/11506347.html

时间: 2024-10-06 15:16:30

[GXOI/GZOI2019]与或和[单调栈]的相关文章

LG5300 「GZOI2019/GXOI2019」与或和 二进制+单调栈

问题描述 Freda 学习了位运算和矩阵以后,决定对这种简洁而优美的运算,以及蕴含深邃空间的结构进行更加深入的研究. 对于一个由非负整数构成的矩阵,她定义矩阵的 \(\texttt{AND}\) 值为矩阵中所有数二进制 \(\texttt{AND(&)}\) 的运算结果:定义矩阵的 \(\texttt{OR}\) 值为矩阵中所有数二进制 \(\texttt{OR(|)}\) 的运算结果. 给定一个 \(N \times N\) 的矩阵,她希望求出: 该矩阵的所有子矩阵的 \(\texttt{AN

(单调栈)poj-2559 Largest Rectangle in a Histogram

A histogram is a polygon composed of a sequence of rectangles aligned at a common base line. The rectangles have equal widths but may have different heights. For example, the figure on the left shows the histogram that consists of rectangles with the

【单调栈】hdu1506 Largest Rectangle in a Histogram

单调栈的介绍及一些基本性质 http://blog.csdn.net/liujian20150808/article/details/50752861 依次把矩形塞进单调栈,保持其单增,矩形中的元素是一个三元组,存储其位置,高度,以及以其为高度的情况下,大矩形的左边界最多扩展到哪里. 每次将新的元素塞进栈的时候,其左边界就是其左侧第一个小于它的矩形的位置+1. 然后,每个矩形出栈的时候,记录其右边界为当前往栈里面塞的矩形的位置-1,然后更新答案即可. 注意最后把所有的矩形出栈,更新答案. #in

BZOJ 3238 AHOI 2013 差异 后缀数组+单调栈

题目大意: 思路:一看各种后缀那就是后缀数组没跑了. 求出sa,height之后就可以乱搞了.对于height数组中的一个值,height[i]来说,这个值能够作为lcp值的作用域只在左边第一个比他小的位置到右边第一个比他小的位置.这个东西很明显可以倍增RMQ+二分/单调栈. 之后就是数学题了 Σlen[Ti] + len[Tj] = (len + 1) * len * (len - 1),之后吧所有求出来的Σ2 * lcp(Ti,Tj)减掉就是答案. 记得答案开long long CODE:

51nod 1215 数组的宽度&amp;poj 2796 Feel Good(单调栈)

单调栈求每个数在哪些区间是最值的经典操作. 把数一个一个丢进单调栈,弹出的时候[st[top-1]+1,i-1]这段区间就是弹出的数为最值的区间. poj2796 弹出的时候更新答案即可 #include<iostream> #include<cstdlib> #include<cstring> #include<cstdio> #include<algorithm> #include<queue> #include<cmath

[poj3250]单调栈 Bad Hair Day

解题关键:将每头牛看到的牛头数总和转化为每头牛被看到的次数,然后用单调栈求解,其实做这道题的目的只是熟悉下单调栈 此题为递减栈 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 #include<cstdlib> 5 #include<stack> 6 #include<iostream> 7 using namespace std; 8 typedef lo

HDU 5033---Building(单调栈)

题目链接 Problem Description Once upon a time Matt went to a small town. The town was so small and narrow that he can regard the town as a pivot. There were some skyscrapers in the town, each located at position xi with its height hi. All skyscrapers loc

POJ 3415 Common Substrings(后缀数组+单调栈)

[题目链接] http://poj.org/problem?id=3415 [题目大意] 求出两个字符串长度大于k的公共子串的数目. [题解] 首先,很容易想到O(n2)的算法,将A串和B串加拼接符相连, 做一遍后缀数组,把分别属于A和B的所有后缀匹配,LCP-k+1就是对答案的贡献, 但是在这个基础上该如何优化呢. 我们可以发现按照sa的顺序下来,每个后缀和前面的串的LCP就是区间LCP的最小值, 那么我们维护一个单调栈,将所有单调递减的LCP值合并, 保存数量和长度,对每个属于B串的后缀更新

poj2796 维护区间栈//单调栈

http://poj.org/problem?id=2796 题意:给你一段区间,需要你求出(在这段区间之类的最小值*这段区间所有元素之和)的最大值...... 例如: 6 3 1 6 4 5 2 以4为最小值,向左右延伸,6 4 5  值为60....... 思路:解决完为这道题目,我才真正明白了单调栈的原理,它就是以某一个值为最小(最大)值,向这个值的两侧延伸,遇到大于它(小于它)的值,就将它延伸的范围扩大,当然,一般来说,要这样做的算法复杂度为o(n^2),但是借助栈这个玩意,维护其单调增