[bzoj1146] [CTSC2008]网络管理Network

Description

　　M公司是一个非常庞大的跨国公司，在许多国家都设有它的下属分支机构或部门。为了让分布在世界各地的N个

部门之间协同工作，公司搭建了一个连接整个公司的通信网络。该网络的结构由N个路由器和N-1条高速光缆组成。

每个部门都有一个专属的路由器，部门局域网内的所有机器都联向这个路由器，然后再通过这个通信子网与其他部

门进行通信联络。该网络结构保证网络中的任意两个路由器之间都存在一条直接或间接路径以进行通信。 高速光

缆的数据传输速度非常快，以至于利用光缆传输的延迟时间可以忽略。但是由于路由器老化，在这些路由器上进行

数据交换会带来很大的延迟。而两个路由器之间的通信延迟时间则与这两个路由器通信路径上所有路由器中最大的

交换延迟时间有关。作为M公司网络部门的一名实习员工，现在要求你编写一个简单的程序来监视公司的网络状况

。该程序能够随时更新网络状况的变化信息（路由器数据交换延迟时间的变化），并且根据询问给出两个路由器通

信路径上延迟第k大的路由器的延迟时间。【任务】 你的程序从输入文件中读入N个路由器和N-1条光缆的连接信息

，每个路由器初始的数据交换延迟时间Ti，以及Q条询问（或状态改变）的信息。并依次处理这Q条询问信息，它们

可能是： 1. 由于更新了设备，或者设备出现新的故障，使得某个路由器的数据交换延迟时间发生了变化。 2. 查

询某两个路由器a和b之间的路径上延迟第k大的路由器的延迟时间。

Input

第一行为两个整数N和Q，分别表示路由器总数和询问的总数。

第二行有N个整数，第i个数表示编号为i的路由器初始的数据延迟时间Ti。

紧接着N-1行，每行包含两个整数x和y。表示有一条光缆连接路由器x和路由器y。

紧接着是Q行，每行三个整数k、a、b。

如果k=0，则表示路由器a的状态发生了变化，它的数据交换延迟时间由Ta变为b

如果k>0，则表示询问a到b的路径上所经过的所有路由器（包括a和b）中延迟

第k大的路由器的延迟时间。

注意N,Q<=80000,任意一个路由器在任何时刻都满足延迟时间小于10^8。

对于所有询问满足0<=K<=N

Output

对于每一个第二种询问（k>0），输出一行。包含一个整数为相应的延迟时间。

如果路径上的路由器不足k个，则输出信息“invalidrequest!”

（全部小写不包含引号，两个单词之间有一个空格）。

Sample Input

5 5
5 1 2 3 4
3 1
2 1
4 3
5 3
2 4 5
0 1 2
2 2 3
2 1 4
3 3 5

Sample Output

3
2
2
invalid request!

Solution

单点修改链上第\(k\)大。

由于我太弱了，想不到正解，就只能暴力维护这个东西了

很自然的可以想到用树剖维护，然后区间第\(k\)大是用的线段树套平衡树，那么这里就全套起来，然后复杂度到了惊人的\(O(m\log^3n)\)。

最骚的是这玩意可以妥妥的过。\(bzoj\)只用了\(25s\)，\(luogu\)最慢的点也只有\(1500ms\)。

码量适中，解法自然，给出题人点赞

然而我码了\(5k+\)。。。

#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;

void read(int &x) {
    x=0;int f=1;char ch=getchar();
    for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}

void print(int x) {
    if(x<0) putchar('-'),x=-x;
    if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}

const int maxn = 8e4+1;

    
int son[maxn*100][2],sz[maxn*100],val[maxn*100],tot,cnt[maxn*100],rd[maxn*100],re[maxn],dfn[maxn];
int v[maxn],n,Q;

struct pii{int fr,sc;};

struct Fhq_Treap {
    int rt;
    void update(int x) {sz[x]=sz[son[x][0]]+sz[son[x][1]]+cnt[x];}
    int newnode(int x) {val[++tot]=x,sz[tot]=cnt[tot]=1;rd[tot]=rand();return tot;}
    int merge(int x,int y) {
        if(!x||!y) return x+y;
        if(rd[x]>rd[y]) return son[x][1]=merge(son[x][1],y),update(x),x;
        else return son[y][0]=merge(x,son[y][0]),update(y),y;
    }
    pii split(int x,int k) {
        if(!x) return (pii){0,0};
        if(sz[son[x][0]]>=k) {
            pii now=split(son[x][0],k);
            son[x][0]=now.sc,now.sc=x,update(x);return now;
        } else {
            pii now=split(son[x][1],k-sz[son[x][0]]-cnt[x]);
            son[x][1]=now.fr,now.fr=x,update(x);return now;
        }
    }
    int find(int x,int k,int &bo,int delta,int e) {
        int ans=0;if(!x) return 0;
        if(k<val[x]) ans=find(son[x][0],k,bo,delta,e);
        else if(k==val[x]) {
            if(delta!=-1||cnt[x]!=1) cnt[x]+=delta,sz[x]+=delta,bo=1;
            ans=sz[son[x][0]]+e*cnt[x];return ans;
        } else ans=find(son[x][1],k,bo,delta,e)+sz[son[x][0]]+cnt[x];
        if(bo) sz[x]+=delta;return ans;
    }
    void insert(int x) {
        if(!rt) return rt=newnode(x),void();
        int bo=0,k=find(rt,x,bo,1,0);if(bo) return ;
        pii now=split(rt,k);rt=merge(now.fr,merge(newnode(x),now.sc));
    }
    void erase(int x) {
        int bo=0,k=find(rt,x,bo,-1,1);if(bo) return ;
        pii now=split(rt,k),now2=split(now.fr,k-1);rt=merge(now2.fr,now.sc);
    }
    int kth(int x) {  // how many number are bigger than x
        int bo=0,k=sz[rt]-find(rt,x,bo,0,1);return k;
    }
};

#define ls p<<1
#define rs p<<1|1
#define mid ((l+r)>>1)

struct Segment_Tree {
    Fhq_Treap s[maxn<<2];
    void modify(int p,int l,int r,int x,int pre,int now) {
        s[p].erase(pre),s[p].insert(now);
        if(l==r) return ;
        if(x<=mid) modify(ls,l,mid,x,pre,now);
        else modify(rs,mid+1,r,x,pre,now);
    }
    int query(int p,int l,int r,int x,int y,int k) {
        if(x<=l&&r<=y) return s[p].kth(k);
        int ans=0;
        if(x<=mid) ans+=query(ls,l,mid,x,y,k);
        if(y>mid) ans+=query(rs,mid+1,r,x,y,k);
        return ans;
    }
    void build(int p,int l,int r) {
        for(int i=l;i<=r;i++) s[p].insert(v[re[i]]);
        if(l==r) return ;build(ls,l,mid),build(rs,mid+1,r);
    }
}SGT;

#undef ls
#undef rs 
#undef mid

struct Heavy_Light_Decomposation {
    struct edge{int to,nxt;}e[maxn<<1];
    int head[maxn],cnt,hs[maxn],top[maxn],fa[maxn],sz[maxn],dep[maxn],dfn_cnt;
    void add(int u,int vv) {e[++cnt]=(edge){vv,head[u]},head[u]=cnt;}
    void ins(int u,int vv) {add(u,vv),add(vv,u);}
    void dfs(int x,int f) {
        sz[x]=1,dep[x]=dep[f]+1,fa[x]=f;
        for(int i=head[x];i;i=e[i].nxt)
            if(e[i].to!=f) {
                dfs(e[i].to,x),sz[x]+=sz[e[i].to];
                if(sz[e[i].to]>sz[hs[x]]) hs[x]=e[i].to;
            }
    }
    void dfs2(int x) {
        dfn[x]=++dfn_cnt,re[dfn_cnt]=x;
        if(hs[fa[x]]==x) top[x]=top[fa[x]];
        else top[x]=x;
        if(hs[x]) dfs2(hs[x]);
        for(int i=head[x];i;i=e[i].nxt)
            if(e[i].to!=fa[x]&&e[i].to!=hs[x]) dfs2(e[i].to);
    }
    int lca(int x,int y) {
        while(top[x]!=top[y]) {
            if(dep[top[x]]<dep[top[y]]) swap(x,y);
            x=fa[top[x]];
        }if(dep[x]>dep[y]) swap(x,y);return x;
    }
    int calc(int x,int y,int k) {
        int ans=0;
        while(top[x]!=top[y]) {
            if(dep[top[x]]<dep[top[y]]) swap(x,y);
            ans+=SGT.query(1,1,n,dfn[top[x]],dfn[x],k);
            x=fa[top[x]];
        }if(dep[x]>dep[y]) swap(x,y);
        ans+=SGT.query(1,1,n,dfn[x],dfn[y],k);
        return ans;
    }
    void solve(int x,int y,int k) {
        if((dep[x]+dep[y]-2*dep[lca(x,y)]+1)<k)
            return puts("invalid request!"),void();
        int l=0,r=1e8,mid,ans=0;
        while(l<=r) {
            mid=((l+r)>>1);
            int t=calc(x,y,mid);
            if(t<=k-1) ans=mid,r=mid-1;
            else l=mid+1;
        }write(ans);
    }
}HLD;

int main() {
    read(n),read(Q);
    for(int i=1;i<=n;i++) read(v[i]);
    for(int i=1,x,y;i<n;i++) read(x),read(y),HLD.ins(x,y);
    HLD.dfs(1,0),HLD.dfs2(1);SGT.build(1,1,n);
    for(int k,a,b,i=1;i<=Q;i++) {
        read(k),read(a),read(b);
        if(!k) SGT.modify(1,1,n,dfn[a],v[a],b),v[a]=b;
        else HLD.solve(a,b,k);
    }
    return 0;
}