BZOJ4129(树上带修莫队)

树上莫队的基本思路是把树按dfs序分块,然后先按x所在块从小到大排序,再按y所在块从小到大排序,处理询问即可。

这道题带修改,再加一个时间维即可。

时间复杂度据说是$n^{\frac53}$,不知道是为什么。

(块大小改成3也过了什么鬼..)

#include <cstdio>
#include <algorithm>
using namespace std;

const int N=50005,M=100005,B=1357,T=223;
int n,m,e,x,y,t,tp,op,tt,t1,t2,a[N],_a[N],bl[N],st[N],hd[N],nx[M],to[M],d[N],a1[N],g[N],h[N],v[N],f[N][16];
struct nd {
    int x,y,t,id;
    bool operator < (const nd &r) const {
        return bl[x]==bl[r.x]?bl[y]==bl[r.y]?t<r.t:bl[y]<bl[r.y]:bl[x]<bl[r.x];
    }
}b[N];
struct nd2 {
    int x,y,t,ls;
    bool operator < (const nd2 &r) const {return t<r.t;}
}c[N];
void ad(int x,int y) {to[++e]=y,nx[e]=hd[x],hd[x]=e;}

void dfs(int x) {
    st[++tp]=x;
    if(tp==B) {tt++; while(tp) bl[st[tp--]]=tt;}
    for(int i=hd[x];i;i=nx[i]) if(!d[to[i]]) d[to[i]]=d[x]+1,f[to[i]][0]=x,dfs(to[i]);
}
int lca(int x,int y) {
    if(d[x]<d[y]) swap(x,y);
    for(int i=15;~i;i--) if(d[f[x][i]]>=d[y]) x=f[x][i];
    if(x==y) return x;
    for(int i=15;~i;i--) if(f[x][i]^f[y][i]) x=f[x][i],y=f[y][i];
    return f[x][0];
}

void up(int x) {
    if(x>n) return;
    if(!g[x]++) h[x/T]++;
}
void _up(int x) {
    if(x>n) return;
    if(!--g[x]) h[x/T]--;
}
void rv(int x) {
    v[x]^=1;
    if(a[x]>n) return;
    if(v[x]) up(a[x]); else _up(a[x]);
}
void gai(int x,int y) {if(v[x]) rv(x),a[x]=y,rv(x); else a[x]=y;}
void rev(int x,int y) {
    while(x^y) {
        if(d[x]<d[y]) swap(x,y);
        rv(x),x=f[x][0];
    }
}
int qry() {
    int r;
    for(int i=0;;i++) if(h[i]!=T) {r=i; break;}
    for(int i=r*T;i<(r+1)*T;i++) if(!g[i]) return i;
    return 233;
}

int main() {
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]),_a[i]=a[i];
    for(int i=1;i<n;i++) scanf("%d%d",&x,&y),ad(x,y),ad(y,x);
    d[1]=1,dfs(1),tt++;
    while(tp) bl[st[tp--]]=tt;
    for(int j=1;j<16;j++)
    for(int i=1;i<=n;i++)
        f[i][j]=f[f[i][j-1]][j-1];
    for(int i=1;i<=m;i++) {
        scanf("%d%d%d",&op,&x,&y);
        if(op) b[++t1].x=x,b[t1].y=y,b[t1].t=i,b[t1].id=t1;
        else c[++t2].x=x,c[t2].y=y,c[t2].t=i,c[t2].ls=_a[x],_a[x]=y;
    }
    sort(b+1,b+1+t1),sort(c+1,c+1+t2);
    for(int i=1,j=1,l=1,r=1;i<=t1;i++) {
        while(t<b[i].t) {
            t++;
            while(j<=t2&&c[j].t==t) gai(c[j].x,c[j].y),j++;
        }
        while(t>b[i].t) {
            while(j>1&&c[j-1].t==t) j--,gai(c[j].x,c[j].ls);
            t--;
        }
        int k=lca(b[i].x,b[i].y);
        rev(b[i].x,l),rev(b[i].y,r),rv(k),a1[b[i].id]=qry(),rv(k),l=b[i].x,r=b[i].y;
    }
    for(int i=1;i<=t1;i++) printf("%d\n",a1[i]);
    return 0;
}
时间: 2024-10-30 22:10:23

BZOJ4129(树上带修莫队)的相关文章

bzoj4129 Haruna’s Breakfast 树上带修莫队+分块

题目传送门 https://lydsy.com/JudgeOnline/problem.php?id=4129 题解 考虑没有修改的序列上的版本应该怎么做: 弱化的题目应该是这样的: 给定一个序列,每次询问区间 \([l, r]\) 中元素的最小没有出现的自然数. 这个弱化的版本可以用离线+线段树二分水掉.但是这个做法显然不太好搬到树上做. 上面的弱化版还有一个莫队做法:可以用莫队维护出来每一个区间的每一个数的出现为次数.把出现过的数通过分块表示出来,于是查询的时候枚举每一个块,寻找第一个不满的

【BZOJ-3052】糖果公园 树上带修莫队算法

3052: [wc2013]糖果公园 Time Limit: 200 Sec  Memory Limit: 512 MBSubmit: 883  Solved: 419[Submit][Status][Discuss] Description Input Output Sample Input Sample Output 84 131 27 84 HINT Source Solution 树上带修莫队 本质还是树上莫队,详情可以转 BZOJ-3757苹果树 但是这里需要修改,就需要一些特殊的地方

【Luogu P4074】[WC2013]糖果公园(树上带修改莫队)

题目描述 Candyland 有一座糖果公园,公园里不仅有美丽的风景.好玩的游乐项目,还有许多免费糖果的发放点,这引来了许多贪吃的小朋友来糖果公园游玩. 糖果公园的结构十分奇特,它由 \(n\) 个游览点构成,每个游览点都有一个糖果发放处,我们可以依次将游览点编号为 \(1\) 至 \(n\).有 \(n-1\) 条双向道路连接着这些游览点,并且整个糖果公园都是连通的,即从任何一个游览点出发都可以通过这些道路到达公园里的所有其它游览点. 糖果公园所发放的糖果种类非常丰富,总共有 \(m\) 种,

[UOJ #58][WC2013]糖果公园(树上带修改莫队)

Description Solution 树上带修改莫队…!VFK的题解写得很清楚啦 (我的程序为什么跑得这么慢…交的时候总有一种自己在卡测评的感觉…) #include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> #include<cmath> #include<algorithm> #define MAXN 100005 typedef long l

[BZOJ 4129]Haruna’s Breakfast(树上带修改莫队)

Description Haruna每天都会给提督做早餐! 这天她发现早饭的食材被调皮的 Shimakaze放到了一棵 树上,每个结点都有一样食材,Shimakaze要考验一下她. 每个食材都有一个美味度,Shimakaze会进行两种操作: 1.修改某个结点的食材的美味度. 2.对于某条链,询问这条链的美味度集合中,最小的未出现的自然数是多少.即mex值. 请你帮帮Haruna吧. Solution 树上带修改莫队 统计答案的时候也分块查询,找到第一个没满的块开始一个一个找 #include<i

【带修莫队】【权值分块】bzoj3196 Tyvj 1730 二逼平衡树

这题用了三种算法写: 分块+二分:O(n*sqrt(n*log(n)) 函数式权值分块:O(n*sqrt(n)) 带修莫队+权值分块:O(n5/3) 结果……复杂度越高的实际上跑得越快……最后这个竟然进第一页了…… #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> using namespace std; int f,C; inline void R(int &

2120: 数颜色(带修莫队)

题目链接:https://www.lydsy.com/JudgeOnline/problem.php?id=2120 2120: 数颜色 Time Limit: 6 Sec  Memory Limit: 259 MBSubmit: 10514  Solved: 4398[Submit][Status][Discuss] Description 墨墨购买了一套N支彩色画笔(其中有些颜色可能相同),摆成一排,你需要回答墨墨的提问.墨墨会像你发布如下指令: 1. Q L R代表询问你从第L支画笔到第R

CF940F Machine Learning(带修莫队)

首先显然应该把数组离散化,然后发现是个带修莫队裸题,但是求mex比较讨厌,怎么办?其实可以这样求:记录每个数出现的次数,以及出现次数的出现次数.至于求mex,直接暴力扫最小的出现次数的出现次数为0的正整数,就一句话,这样看似会超时,实际上是O(√n)的复杂度.为什么?假设存在出现1,2,...,x的出现次数,则Σi(1<=i<=x)<=n,即x*(x+1)<=2*n,所以x至多是√n级别.很多人再把出现次数分块,根本没必要.然后考虑把数组分块的块大小,每次移动左指针,为O(n*块大

莫队 + 带修莫队

莫队其实就是一个带优化的暴力,通过将区间询问按一定规则进行排序,从而优化过程,求出答案. 举一例子:(例子不具备权威性,只是让读者了解莫队是干啥的) /* 输入四个区间 1 4 初始条件,L= R = 0, 将R遍历到4 需要走4步 L走一步,共5次 4 8 继承上一次 L 和 R 的值,L从1到4 需要3次,R从4到8,需4次, 总计8次 2 9 同理继承, L回退2次, R前进一次 总计3次 1 2 同理,L回退1次,R回退7次 总计8次 如果直接暴力,计算机将要计算 5+8+3+8=24次