2018牛客多校2 - J farm 随机乱搞/二进制分组

题意:给定n*m的格子,每个格子有不同的种类,q次操作,每次操作使[x1,y1]到[x2,y2]的格子除了k类型的以外都删除,最后单次询问所有格子被删了几个

官方题解提到了两种有意思的做法,随机和二进制分组

目前我写了随机的做法,简单粗暴好懂

给每种类型打个随机权值,操作覆盖到的区间都加上这个权值
最后查询的时候只需这道这个点的值是不是该类型的权值的倍数就行了

就这么简单
实现上只需套路作差取前缀和就能得到单点的值,总复杂度\(O(n)\)

(WA了几发忘记递推前缀了...)

另外提一下二进制分组的思路

对于每个操作的整体而不考虑细节来说,
普通的是更新\(O(1)\),针对特定的一组
要比较的是\(O(n)\),对应于除了该类型外的其他所有组

那么二进制分组就把各个类型按二进制归类,如果某一位是1就把它归类到某一组,总共\(log_2n\)组
要比较是否有别的数打到这个格子上,那么必然在二进制的某一位上存在差异
因此可以更新\(O(logn)\)
查询也是\(O(logn)\)

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define rrep(i,j,k) for(int i=j;i>=k;i--)
#define erep(i,u) for(int i=head[u];~i;i=nxt[i])
#define print(a) printf("%lld",(ll)(a))
#define printbk(a) printf("%lld ",(ll)(a))
#define println(a) printf("%lld\n",(ll)(a))
using namespace std;
const int MAXN = 1e5+11;
const int MAXM = 2e6+11;
const int MOD = 1e9+7;
typedef long long ll;
unsigned int xjb=2333333;
int Rand(){
    return (xjb=xjb*12345+23333)%MOD+1;
}
ll read(){
    ll x=0,f=1;register 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;
}
vector<vector<ll> > G,type,pre;
vector<ll> vec;
int main(){
    int n,m,op;
    while(cin>>n>>m>>op){
        G.clear();type.clear();vec.clear();pre.clear();
        G.resize(n+3);type.resize(n+3);pre.resize(n+3);
        rep(i,0,n+2){
            G[i].resize(m+3);
            type[i].resize(m+3);
            pre[i].resize(m+3);
        }
        rep(i,1,n) rep(j,1,m) type[i][j]=read();
        vec.push_back(Rand());
        rep(i,1,n)rep(j,1,m) vec.push_back(Rand());
        rep(i,1,op){
            int x_1=read();
            int y_1=read();
            int x_2=read();
            int y_2=read();
            int k=read();
            G[x_1][y_1]+=vec[k];
            G[x_2+1][y_1]-=vec[k];
            G[x_1][y_2+1]-=vec[k];
            G[x_2+1][y_2+1]+=vec[k];
        }
        ll val=0,cnt=0;
        rep(i,1,n) rep(j,1,m){
            pre[i][j]=pre[i-1][j]+pre[i][j-1]-pre[i-1][j-1]+G[i][j];
            if(pre[i][j]%vec[type[i][j]]!=0) cnt++;
        }
        println(cnt);
    }
    return 0;
}