SD省队集训2019Day8之“有没有空”

最新推荐文章于 2021-08-19 09:22:19 发布
最新推荐文章于 2021-08-19 09:22:19 发布
阅读量237 收藏
点赞数
原文链接：http://www.cnblogs.com/water-lift/p/10993782.html
版权

有没有空(busy)（[Ynoi2018]天降之物）

给你一个长为 n 的序列 a
你需要实现 m 个操作,操作有两种:
1.把序列中所有值为 x 的数的值变成 y
2.找出一个位置 i 满足 ai==x,找出一个位置 j 满足 aj==y,使得|i-j|最小,并输出|i-j|

部分分：二分

考虑把整个区间分成两部分，那么这两个数要么都在左边，要么都在右边，要么一左一右。前两种情况可以递归解决，同时记录当前区间中最左端和最右段的x和y，然后直接算。

#include<bits/stdc++.h>
using namespace std;
int n,m;
int a[100001];
int fir[100001],to[100001],when[100001],nxt[100001],cnt;
inline void solve(int l,int r,int x,int y,int&ans,int&lx,int&ly,int&rx,int&ry);
inline int calc(int num){
    register int tim=0;
    while(fir[num]){
        register int p=fir[num];
        while(when[p]<tim&&nxt[p])p=nxt[p];
        if(when[p]<tim)break;
        if(to[p]==num)break;
        num=to[p];
        tim=when[p];
    }
    return num;
}
int main(){
    freopen("busy.in","r",stdin);
    freopen("busy.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(register int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    register int la=0;
    for(register int mm=1;mm<=m;mm++){
        register int opt,x,y;
        scanf("%d%d%d",&opt,&x,&y);
        x^=la;
        y^=la;
        if(opt==1){
            to[++cnt]=y;
            when[cnt]=mm;
            int p=fir[x];
            if(!p)fir[x]=cnt;
            else{
                while(nxt[p])p=nxt[p];
                nxt[p]=cnt;
            }
        }else if(opt==2){
            register int ans,lx,ly,rx,ry;
            solve(1,n,x,y,ans,lx,ly,rx,ry);
            if(ans==-1)printf("Chtholly\n"),la=0;
            else printf("%d\n",ans),la=ans;
        }
    }
}
inline void solve(int l,int r,int x,int y,int&ans,int&lx,int&ly,int&rx,int&ry){
    if(l==r){
        ans=-1;
        if(calc(a[l])==x)lx=rx=l;
        else lx=rx=-1;
        if(calc(a[r])==y)ly=ry=r;
        else ly=ry=-1;
        if(x==y&&x==calc(a[l])){
            ans=0;
            lx=rx=l;
            ly=ry=r;
        }
        return;
    }
    register int mid=(l+r)/2;
    register int lans,llx,lly,lrx,lry;
    register int rans,rlx,rly,rrx,rry;
    solve(l,mid,x,y,lans,llx,lly,lrx,lry);
    solve(mid+1,r,x,y,rans,rlx,rly,rrx,rry);
    ans=INT_MAX;
    if(lans!=-1&&lans<ans)ans=lans;
    if(rans!=-1&&rans<ans)ans=rans;
    if(llx==-1)lx=rlx;else lx=llx;
    if(lly==-1)ly=rly;else ly=lly;
    if(rrx==-1)rx=lrx;else rx=rrx;
    if(rry==-1)ry=lry;else ry=rry;
    if(lrx!=-1&&rly!=-1)ans=min(ans,rly-lrx);
    if(lry!=-1&&rlx!=-1)ans=min(ans,rlx-lry);
    if(ans==INT_MAX)ans=-1;
}

做法

根号分治。

首先看这个查询操作。如果我们将所有值的位置按从小到大的顺序记录下来，那么直接暴力查询就是\(sz[x]+sz[y]\)，其中\(sz[x]\)表示\(x\)这个值出现的次数。考虑如何优化这个大暴力。于是就可以用根号分治的想法啦。我们设一个阈值为\(lim\)，用这个阈值来讨论。

  1. \(sz[x],sz[y]\leq lim\)直接暴力查询。

  2. \(sz[x]> lim\)可以预处理出\(x\)与其他所有值的最小距离，然后直接\(O(1)\)查询。预处理的复杂度是\(O(\frac {n}{lim} \ast n)\)

于是可以把\(lim\)设为\(\sqrt n\)，这显然是最优的。

但如果加入了修改操作，我们不可能每一次修改之后还暴力重新预处理，应该需要一个东西来优化这个预处理。

我们先研究一下修改的操作。

首先，显然\(x,y\)是等价的两个值，可以直接交换。

  1. \(sz[x],sz[y]<=lim\)直接暴力合并两个的位置集合，这样的复杂度是\(O(lim+lim)\)。

  2. \(sz[x],sz[y]>=lim\)直接暴力重构，重新预处理出\(y\)到所有其他值的最小距离。一次重构的复杂度是\(O(n)\)的，但最多重构\(O(\frac {n}{lim})\)次，所以这里的复杂度是\(O(n\ast \frac {n}{lim})\)。

  3. \(sz[x]>=lim,sz[y]<=lim\)这里就不好处理了，直接重构也不对，暴力合并也不对。我们发现把\(y\)合并进\(x\)中的均摊位置数是\(O(n)\)的。于是我们可以对于每一个\(sz>=lim\)的数维护一个新的集合\(psz\)，再维护一个\(ans[A][B]\)数组，表示所有\(sz>=lim\)的数\(A\)到所有其他数\(B\)去除在\(psz\)里的最小距离。每次将\(y\)合并入\(x\)的时候，我们直接让它合并入\(psz[x]\)中，然后用\(ans[A][y]\)去更新\(ans[A][x]\)。这样的复杂度就变得很好看了。这样的复杂度是\(O(lim+lim)\)的。如果合并后\(psz\)的大小超过\(lim\)，则暴力重新处理\(x\)到其他所有数的最小距离。这样的重构式\(O(n)\)的，但最多进行\(O(\frac {n}{lim})\)次，所以这样的复杂度是\(O(n\ast \frac {n}{lim})\)。这样同时也保证pszpszpsz的大小始终小于\(lim\)。

那么接下来查询就容易许多了。

  1. \(sz[x],sz[y]<=lim\)依然暴力合并，复杂度\(O(lim+lim)\)。

  2. \(sz[x],sz[y]>=lim\)合并\(psz[x]\)与\(psz[y]\)，再加上\(ans\)里的答案就是真实答案。这样的复杂度是\(O(lim+lim)\)。

  3. \(sz[x]>=lim,sz[y]<=lim\)与上述一样，没区别。

所以总的复杂度就是\(\sum_{i=1}^n (lim+\frac {n}{lim})\)，取\(lim=\sqrt(n)\)时最优。

于是就做完了。

代码

#include<bits/stdc++.h>
using namespace std;
#define res register int
#define LL long long
#define inf 0x3f3f3f3f
#define eps 1e-10
#define RG register
inline int read() {//快读
    res s=0,ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')s=s*10+ch-'0',ch=getchar();
    return s;
}
inline LL Read() {//快读
    RG LL s=0;
    res ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')s=s*10+ch-'0',ch=getchar();
    return s;
}
inline void swap(res &x,res &y) {//交换两个变量的值，较快
    x^=y^=x^=y;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());//随机数生成器
typedef vector<int> vec;
const int N=1e5+10;
const int BB=500;
namespace MAIN {
    vec v[N];
    int n,m,block,st[N],top,bigx=1,ans[N/BB+10][N],id[N],big[N],tim,a[N],sz[N],psz[N],lastans,ys[N];
    inline int newnode(){           //创建新节点
        return top?st[top--]:++bigx;
    }
    inline void init(const res &B){//初始化，创建新节点时使用
        for(res i=1;i<=n;i++)ans[B][i]=inf;
        for(res i=1,now=inf;i<=n;i++)
            if(id[i]==tim)now=0;
            else ans[B][a[i]]=min(ans[B][a[i]],++now);
        for(res i=n,now=inf;i;i--)
            if(id[i]==tim)now=0;
            else ans[B][a[i]]=min(ans[B][a[i]],++now);
    }
    inline void bigbuild(const res &val){//大于lim时，重构
        big[val]=newnode(),tim++;
        for(res i=1;i<=n;i++)if(a[i]==val)id[i]=tim;
        init(big[val]),ans[big[val]][val]=0;
    }
    inline void rebuild(const res &A,const res &B){//重构
        tim++;
        if(big[A])st[++top]=big[A];
        for(res i=1;i<=n;i++)if(a[i]==A||a[i]==B)id[i]=tim,a[i]=B;
        psz[B]=0,init(big[B]);
    }
    inline void merge(const res &A,const res &B){//合并
        res i=sz[A],j=sz[B]<block?sz[B]:psz[B],k=i+j;
        RG vec tmp=v[B];
        v[B].resize((k<<1)+10);
        while(i&&j)v[B][k--]=(v[A][i]>tmp[j]?v[A][i--]:tmp[j--]);
        while(i)v[B][k--]=v[A][i--];
        while(j)v[B][k--]=tmp[j--];
    }
    inline void modify(res x,res y){
        res A=ys[x],B=ys[y];
        if(A==B||!sz[A])return; //相等或者不存在，无需操作
        if(sz[A]>sz[B])swap(A,B),swap(x,y),ys[y]=0,ys[x]=B;
        else ys[x]=0;
        if(!A||!B)return;
        if(sz[B]<block){            //sz小于lim，暴力合并
            if(sz[A]+sz[B]<block){  //直接做
                merge(A,B);
                for(res i=1;i<=bigx;i++)ans[i][B]=min(ans[i][B],ans[i][A]);
                for(res i=1;i<=sz[A];i++)a[v[A][i]]=B;
            }
            else {
                big[B]=newnode(),tim++;
                for(res i=1;i<=sz[B];i++)id[v[B][i]]=tim;
                for(res i=1;i<=sz[A];i++)id[v[A][i]]=tim,a[v[A][i]]=B;
                init(big[B]);
            }
        }
        else
        if(sz[A]<block){            //sz一大一小
            if(psz[B]+sz[A]<block){ //改为合并psz
                merge(A,B);
                for(res i=1;i<=bigx;i++)ans[i][B]=min(ans[i][B],ans[i][A]);
                for(res i=1;i<=sz[A];i++)a[v[A][i]]=B;
                psz[B]+=sz[A];
            }
            else rebuild(A,B);      //重构
        }
        else rebuild(A,B);
        sz[B]+=sz[A],sz[A]=0;
    }
    inline int merge_ans(const res &A,const res &B){
        res i=1,j=1,sa=sz[A],sb=sz[B],ret=inf;
        if(sz[A]>=block)sa=psz[A];  //大于lim时改为合并psz
        if(sz[B]>=block)sb=psz[B];  //同上
        if(!sa||!sb)return inf;     //不存在则无解，因为调用时是取min，所以可以return无穷大
        while(i<=sa&&j<=sb)ret=min(ret,v[A][i]<v[B][j]?v[B][j]-v[A][i++]:v[A][i]-v[B][j++]);//合并
        if(i<=sa)ret=min(ret,abs(v[A][i]-v[B][sb]));//求答案
        if(j<=sb)ret=min(ret,abs(v[A][sa]-v[B][j]));//同上
        return ret;
    }
    inline int query(res x,res y){
        res A=ys[x],B=ys[y];
        if(A==B)return sz[A]?0:-1;                  //相等特判
        if(!sz[A]||!sz[B])return -1;                //没有出现，肯定无解
        if(sz[A]>sz[B])swap(x,y),swap(A,B);         //交换后仍等价
        if(sz[B]<block)return merge_ans(A,B);       //都小于lim，暴力合并
        if(sz[A]<block)return min(ans[big[B]][A],merge_ans(A,B));//合并psz[x]和psz[y]，再加上ans[][]
        return min(min(ans[big[A]][B],ans[big[B]][A]),merge_ans(A,B));//同上
    }
    inline void MAIN(){
        n=read(),m=read(),block=BB;
        for(res i=1;i<=n;i++)sz[a[i]=read()]++,ys[i]=i;
        for(res i=1;i<=n;i++)
            if(sz[i]>=block)bigbuild(i),v[i].resize(10);    //sz[x]>lim，重构
            else v[i].resize(sz[i]+10),sz[i]=0;
        for(res i=1;i<=n;i++)if(sz[a[i]]<block)v[a[i]][++sz[a[i]]]=i;
        while(m--){
            res opt=read(),x=read()^lastans,y=read()^lastans;
            if(opt==1)modify(x,y);
            else {
                res ret=query(x,y);
                if(ret==-1)puts("Chtholly"),lastans=0;
                else printf("%d\n",lastans=ret);
            }
        }
    }
}
int main() {
//    srand((unsigned)time(NULL));
//    freopen("graph.in","r",stdin);
//    freopen("graph.out","w",stdout);
    MAIN::MAIN();
    return 0;
}

转载于:https://www.cnblogs.com/water-lift/p/10993782.html

weixin_30917213
关注
ynoi2018
weixin_30724853的博客
11-20 197
题解： 全分块是啥操作啊。。 而且都好难。。 1.未来日记 这个比较简单 对每个块开个线段树维护权值 $n\sqrt{n}logn$ 这个会炸空间 并不能做。。。 但还是说一下做法 首先考虑分块 然后在每个块上我们要支持单点修改，查区间第k大 比较自然的想到了用线段树维护 如果没有修改就是在$\sqrt{n}$颗树上一起二分 多了修改操作 对于整块，我们考虑要打一个la...
SD省队集训2019Day11之“loopy”
weixin_30384217的博客
06-09 253
loopy 题目描述 提交答案题。 你要在从网格图的边上选出一些边使得这些边形成一个简单环。这个网格图的有些格子中的数字,数字表示这个格子周围有几条边被选中了。数据保证解是唯一的。 做法（技巧） “0”的周围没有线段： 当您解决一道数回谜题时，确定哪些点之间不能连接也是同样重要的。最好的方法是将这些不可连接的点之间用X标记。让我们看一下例子中位于中间的“0”。“0”意味着它的四周围均没有线段，...
SD省队集训2019Day9之“轻拍翻转小魔女”
weixin_30773135的博客
06-09 210
轻拍翻转小魔女(flipflap)（[Ynoi2014]置身天上之森） 题目描述 线段树是一种特殊的二叉树,满足以下性质: 每个点和一个区间对应,且有一个整数权值; 根节点对应的区间是[1,n]; 如果一个点对应的区间是[l,r],且 l<r,那么它的左孩子和右孩子分别对应区 间[l,m]和[m+1,r],其中 m=floor((l+r)/2)(floor 表示向下取整); 如果一个点对应的...
HDU 5412 CRB and Queries（整体二分）
ZSQ
03-02 972
Description 一个序列中有n个整数，m个操作，操作有两种： 1 i x 表示将i位置的数改为x 2 i j k 表示询问区间[i,j]的第k小的数是多少 Input 第一行为一整数n表示序列长度，第二行为n个整数ai表示该序列，然后是一整数m表示操作次数，最后m行每行表示一个操作 (1<=n,m<=10^5,1<=ai<=10^9,1<=l<=r<=n,1<=k<=r-l+1)
【线段树】最大值（单点）
学习成神之路
01-14 463
题意：在N（1<=N<=100000）个数A1…An组成的序列上进行M(1<=M<=100000)次操作，操作有两种：(1)1 x y：表示修改A[x]为y；(1)2 x y：询问x到y之间的最大值。思路：线段树，然后以最大值为权建数…..程序： const maxn=500000; var a:array [1..maxn] of longint; i,n,m,j,w,x,y:longint
2016山东省NOI省队集训DAY7 题目题解数据标程 NOIP省选省队集训
04-18
《2016山东省NOI省队集训DAY7 题目题解数据标程 NOIP省选省队集训》是针对全国青少年信息学奥林匹克（NOI）及山东省选拔赛省队集训的一项重要教学资料。这个压缩包包含了集训的第七天的相关内容，旨在帮助参赛学生...
2016山东省NOI省队集训DAY2 题目题解数据标程
04-18
《2016山东省NOI省队集训DAY2 题目题解数据标程》 本资源是关于2016年山东省全国信息学奥林匹克（NOI）省队集训第二天的训练题目解析及数据标程。信息学奥林匹克是一项针对中学生的编程竞赛，旨在提升青少年在...
2016山东省NOI省队集训DAY5 题目题解数据标程 NOIP省选集训
04-18
【标题】"2016山东省NOI省队集训DAY5 题目题解数据标程 NOIP省选集训"所涉及的主要知识点包括： 1. NOI（全国青少年信息学奥林匹克竞赛）：NOI是中国最高级别的青少年信息学竞赛，旨在选拔优秀学生参加国际信息学...
2016山东省NOI省队集训DAY4 题目题解数据标程 NOIP省选集训
04-18
【标题】"2016山东省NOI省队集训DAY4 题目题解数据标程 NOIP省选集训"所涉及的知识点主要围绕全国青少年信息学奥林匹克（National Olympiad in Informatics, NOI）及其省级选拔赛（NOIP）的训练活动展开。...
2016山东省NOI省队集训DAY6 题目题解数据标程 NOIP省选集训
04-18
【标题】"2016山东省NOI省队集训DAY6 题目题解数据标程 NOIP省选集训"所涉及的主要知识点包括： 1. NOI（全国青少年信息学奥林匹克竞赛）：NOI是中国最高级别的青少年编程竞赛，旨在选拔优秀的信息学人才参加国际...
【HDU5751 BestCoder Round 84E】【FFT + 线段树求最值】Eades 最大数出现次数为[1~n]的区间个数
snowy_smile的博客
07-25 1942
Eades    Accepts: 1    Submissions: 11  Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) 问题描述 Peter有一个序列a_1, a_2, ..., a_na​1​​,a​2​​,...,a​n​​.
洛谷 P3372 线段树 1（树状数组做法）
我要吃熊猫
11-14 713
两只树状数组
Yali 2019-8-15 test solution
weixin_30292843的博客
08-15 117
T1. 送货 Description 物流公司要用m辆车派送n件货物.货物都包装成长方体,第i件的高度为hi,重量为wi.因为车很小,一辆车上的货物必须垒成一摞.又因为一些不可告人的原因,一辆车上货物的重量在所有重量中大小排名要连续,但载重量却不限.每辆车的样子一模一样,车本身的最高点距地x,车的放货部位与地面平行,且上表面距地y. 一些快速通道有车辆高度限制,工作人员需要事先规划路线,...
SD省队集训2019Day2之“大家佛”
weixin_30909575的博客
06-09 229
大家佛( cut ) 题目描述 提交答案题。 把一个矩阵划分成k个四连通块，使得包含的所有点的和最大的一个连通块的这个和与包含的所有点的和最小的一个连通块的这个和的差最小。 部分分（骗分）做法 A:手算 针对前几个规模较小的点可以这样做。 B:蛇形填 先求出每个连通块的和的平均值(\(\sum a_{ij}\div k\))，蛇形填的时候一旦超过这个值，就换下一个连通块。 #include &lt...
SD省队集训2019Day10之“Distribution”
weixin_30892987的博客
06-09 256
Distribution(distribution) 题目描述 令 \(p\) 是一个 \((0, 1)\) 之间的实数,\(n\) 是一个 \([1, 100]\) 之间的正整数。 令 \(X_1 , X_2 , . . . , X_n\) 为 \(n\) 个独立的随机变量,并且满足 \(Pr(X_i = 1) = p, Pr(X_i = 0) = 1 − p\),考虑下面的随机变量\(X =\...
【uva12345】Dynamic len
Facico的博客
07-08 1102
Description有n个数编号从0→n-1,两种操作： Q L R:询问编号为L→R-1的数中共有多少种不同的数 M X Y：将编号为X的数改为Y 共有m个操作Solution一开始满脸懵逼……后来才发现是待修改莫队。方法1树套树,很裸啊!码力要求大！方法2类似暴搜，用分块来做，速度快，细节有些多。方法3待修改的莫队算法，很裸，有些快，代码短。 我选了它。 不会的参见待修改的莫队算法学
SD省队集训2019Day1之“等你哈苏德”
weixin_30389003的博客
05-29 281
等你哈苏德（wait） 题目描述 Joker 有一些黑白区间\([l_i,r_i]\)，有些区间已经被指定了颜色，有些却没有。你要指定 这些未染色区间的颜色，使得数轴上对于每个点，覆盖他的黑区间个数和白区间个数差 的绝对值小于等于1。 输入格式 从文件 wait.in 中读入数据。 输入正整数 m, n 接下来 m 行每行三个整数 Li, Ri,wi，保证 1 ≤ Li ≤ Ri ≤ n,wi ∈...
省队集训Day1 总统选举
aklm45097的博客
07-07 90
【题目大意】 一个$n$个数的序列，$m$次操作，每次选择一段区间$[l, r]$，求出$[l, r]$中出现超过一半的数。 如果没有超过一半的数，那么就把答案钦定为$s$，每次会有$k$个数进行改变，给出下标，改变成当前的答案$s$。 $n, m \leq 5*10^5, \sum k\leq 10^6$ By FJSDFZ ditoly 【题解】 用这题的方法进行线段树操...
[Ynoi2018]天降之物
StaroForgin的博客
08-19 210
「 弑尽破净的第四分块」，看来出题人越来越中二了。
数据结构精讲：线段树与树形结构的应用
"《数据结构漫谈》是江苏省2012年信息学集训队论文，由许昊然（国家队大神）撰写，共计148页，内容涵盖数据结构在序列中的应用、DFS序、树形结构、函数式数据结构、函数式块状链表、指纹算法、扩展后缀数组等多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值