【BZOJ1146】网络管理(线段树)

最新推荐文章于 2019-08-12 07:56:00 发布
最新推荐文章于 2019-08-12 07:56:00 发布
阅读量308 收藏 1
点赞数
分类专栏： 线段树 树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Etta19/article/details/75456762
版权

    来来来权限题但是有入门OJ的传送门

I Think

    题意：伟大的树上带修改第k大
    思路&实现：对于每个点建一颗权值线段树，维护其到根节点路径上的所有点权。查询(a,b)第k大时先找到lc=Lca(a,b),再用a b树上节点size和-lc与Fa[lc]树上节点size和决定如何左右递归就好。
    Attention！
    1)局部变量要注意初始化(比如说Query里的tmp)
    2)在删除节点调用del(int &rt)不能丢&（类似Swap函数也是）
    3)用于离散化的B[]数组，由于可能加入更新的值，所以大小要开得比N大
    4)计算Lca时，u和v的判等需要放在前面的if外，因为题目并没有说不能查询两个相同的点。
    鉴于以上错误，成功刷新了自己的调题时间记录……

    先上一份会TLE的代码，准备有时间再打一份只有修改值使用树状数组结合的。

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lowbit(x) x&(-x)
using namespace std;
template <typename T> void read(T &x) {
    T f=1;x=0; char ch=getchar();
    while(ch>'9'||ch<'0') { if(ch=='-') f=-1;ch=getchar(); }
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    x*=f;
}
const int sm = 8e4+5;
const int sn = sm*300;
int N,Q,tot,cnt;
int A[sm],B[sm<<1],C[sn],Ls[sn],Rs[sn];
int Lt[sm],Rt[sm],dep[sm],Fa[sm][20];
int hd[sm<<1],to[sm<<1],nxt[sm<<1];
struct query {
    int x,y,z;
}q[sm];
void Swap(int &x,int &y) { int t=x;x=y;y=t; }
void add(int f,int t) {
    to[++tot]=t,nxt[tot]=hd[f],hd[f]=tot;
    to[++tot]=f,nxt[tot]=hd[t],hd[t]=tot;
}
int Hash(int x) {
    return lower_bound(B+1,B+cnt+1,x)-B;
}
void Insert(int &rt,int l,int r,int p,int val) {
    if(!rt) rt=++tot; C[rt]+=val;
    if(l==r) return ;
    int m=(l+r)>>1;
    if(p<=m) Insert(Ls[rt],l,m,p,val);
    else Insert(Rs[rt],m+1,r,p,val);
}
void Dfs(int x,int f) {
    dep[x]=dep[Fa[x][0]=f]+1,Lt[x]=++tot;
    for(int i=1;i<20;++i)
        Fa[x][i]=Fa[Fa[x][i-1]][i-1];
    for(int i=hd[x];i;i=nxt[i]) 
        if(to[i]!=f) Dfs(to[i],x);
    Rt[x]=tot;
}
int Lca(int u,int v) {
    if(dep[u]!=dep[v]) {
        if(dep[u]<dep[v])Swap(u,v);
        for(int i=19;i>=0;--i)
            if(dep[Fa[u][i]]>dep[v]) u=Fa[u][i];
        u=Fa[u][0];
    }   
    if(u==v) return u;
    for(int i=19;i>=0;--i)
        if(Fa[u][i]!=Fa[v][i]) u=Fa[u][i],v=Fa[v][i];
    return Fa[u][0];
}
struct BIT {
    int root[sn];
    BIT() { memset(root,0,sizeof(root)); }
    void Modify(int x,int p,int val) {
        for(int i=x;i<=N;i+=lowbit(i))  
            Insert(root[i],1,cnt,p,val);
    }
    void Add(int l,int r,int p,int val) {
        Modify(l,p,val),Modify(r+1,p,-val);
    }
    void Query(int k,int a,int b) {
        int lc=Lca(a,b),l=1,r=cnt,m;
        int rt[4][30],n[4]={0,0,0,0},flag[4]={1,1,-1,-1};
        int pos[4]={Lt[a],Lt[b],Lt[lc],Lt[Fa[lc][0]]};
        if(dep[a]+dep[b]-dep[lc]-dep[Fa[lc][0]]<k) 
            puts("invalid request!");
        else {
            for(int i=0;i<4;++i) 
                for(int j=pos[i];j;j-=lowbit(j))
                    rt[i][++n[i]]=root[j];
            while(l<r) {
                int tmp=0;m=(l+r)>>1;
                for(int i=0;i<4;++i) 
                    for(int j=1;j<=n[i];++j)
                        if(rt[i][j]) tmp+=C[Rs[rt[i][j]]]*flag[i];
                if(k<=tmp) {
                    l=m+1;
                    for(int i=0;i<4;++i) 
                        for(int j=1;j<=n[i];++j)
                            if(rt[i][j])rt[i][j]=Rs[rt[i][j]];
                } else {
                    r=m,k-=tmp;
                    for(int i=0;i<4;++i) 
                        for(int j=1;j<=n[i];++j)
                            if(rt[i][j])rt[i][j]=Ls[rt[i][j]];
                }
            }
            printf("%d\n",B[l]);
        }
    }
}tree;
int main() {
    read(N),read(Q);
    for(int i=1;i<=N;++i) read(A[i]),B[++cnt]=A[i];
    for(int i=1,x,y,z;i<N;++i) read(x),read(y),add(x,y);
    tot=0,Dfs(1,0),tot=0;
    for(int i=1;i<=Q;++i) {
        read(q[i].x),read(q[i].y),read(q[i].z);
        if(!q[i].x) B[++cnt]=q[i].z;
    }
    sort(B+1,B+cnt+1);
    cnt=unique(B+1,B+cnt+1)-B-1;
    for(int i=1;i<=N;++i)
        tree.Add(Lt[i],Rt[i],Hash(A[i]),1);
    for(int i=1;i<=Q;++i) 
        if(!q[i].x) {
            tree.Add(Lt[q[i].y],Rt[q[i].y],Hash(A[q[i].y]),-1);
            tree.Add(Lt[q[i].y],Rt[q[i].y],Hash(q[i].z),1);
            A[q[i].y]=q[i].z;
        }
        else tree.Query(q[i].x,q[i].y,q[i].z);
    return 0;
}

来一份AC代码～

#include<cstdio>
#include<algorithm>
#define lowbit(x) x&(-x)

const int sm = 8e4+5;
const int Sn = sm*128;

int N,Q,tot,cnt,ss;
int C[Sn],Rs[Sn],Ls[Sn];
int A[sm],B[sm<<1],St[sm],Rt[sm];
int to[sm<<1],nxt[sm<<1],hd[sm];
int Fa[sm],tp[sm],sn[sm],sz[sm],dp[sm],pl[sm],en[sm];
struct Que {
    int k,a,b;
}q[sm];

namespace Tree {
    int use[4][sm];
    template <typename T> void read(T &x) {
        char ch=getchar();x=0;int f=1;
        while(ch>'9'||ch<'0') { if(ch=='-')f=-1; ch=getchar(); }
        while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
        x*=f;
    }
    void Add(int u,int v) {
        to[++tot]=v,nxt[tot]=hd[u],hd[u]=tot;
        to[++tot]=u,nxt[tot]=hd[v],hd[v]=tot;
    }
    void Swap(int &x,int &y) { int t=x;x=y;y=t; }
    int Hash(int x) { return std::lower_bound(B+1,B+cnt+1,x)-B; }

    int Insert(int pre,int l,int r,int p,int val) {
        int cur=++tot; C[cur]=C[pre]+val;
        if(l==r) return cur; int m=(l+r)>>1;
        if(p<=m) Ls[cur]=Insert(Ls[pre],l,m,p,val),Rs[cur]=Rs[pre];
        if(p >m) Rs[cur]=Insert(Rs[pre],m+1,r,p,val),Ls[cur]=Ls[pre];
        return cur;
    }
    void Dfsa(int x,int fa) {
        dp[x]=dp[fa]+1,Fa[x]=fa;
        sn[x]=0,sz[x]=1;
        Rt[x]=Insert(Rt[fa],1,cnt,Hash(A[x]),1);
        for(int i=hd[x];i;i=nxt[i])
            if(to[i]!=fa) {
                Dfsa(to[i],x);
                sz[x]+=sz[to[i]];
                if(sz[to[i]]>sz[sn[x]])
                    sn[x]=to[i];
            }
    }
    void Dfsb(int x,int top) {
        tp[x]=top,pl[x]=++ss;
        if(sn[x]) Dfsb(sn[x],top);
        for(int i=hd[x];i;i=nxt[i])
            if(to[i]!=Fa[x]&&to[i]!=sn[x])
                Dfsb(to[i],to[i]);
        en[x]=ss;
    }
    int Lca(int u,int v) {
        while(tp[u]!=tp[v]){
            if(dp[tp[u]]<dp[tp[v]])Swap(u,v);
            u=Fa[tp[u]];
        }
        if(dp[u]>dp[v])Swap(u,v);
        return u;
    }
    void TModify(int u,int v,int p,int val) {
        for(int i=u;i<=N;i+=lowbit(i))    
            St[i]=Insert(St[i],1,cnt,p,val);
        for(int i=v;i<=N;i+=lowbit(i))
            St[i]=Insert(St[i],1,cnt,p,-val);
    }
    int Sum(int x,int y) {
        int res=0;
        for(int i=1;i<=y;++i)
            res+=C[Rs[use[x][i]]];
        return res;
    }
    void RQuery(int a,int b,int K) {
        int l=1,r=cnt,Lc=Lca(a,b),Gc=Fa[Lc];
        if(dp[a]+dp[b]-dp[Lc]-dp[Gc]<K) { printf("invalid request!\n"); return ; }
        int ct[4]={0,0,0,0},tmp[4]={pl[a],pl[b],pl[Lc],pl[Gc]};
        for(int i=0;i<4;++i)
            for(int j=tmp[i];j;j-=lowbit(j))
                use[i][++ct[i]]=St[j];
        a=Rt[a],b=Rt[b],Lc=Rt[Lc],Gc=Rt[Gc];
        while(l<r) {
            int m=(l+r)>>1,tmp;
            tmp=C[Rs[a]]+C[Rs[b]]+Sum(0,ct[0])+Sum(1,ct[1])-C[Rs[Lc]]-C[Rs[Gc]]-Sum(2,ct[2])-Sum(3,ct[3]);
            if(tmp<K) {
                K-=tmp,r=m;  a=Ls[a],b=Ls[b],Lc=Ls[Lc],Gc=Ls[Gc];
                for(int i=0;i<4;++i)
                    for(int j=1;j<=ct[i];++j)
                        use[i][j]=Ls[use[i][j]];
            }
            else {
                a=Rs[a],b=Rs[b],Lc=Rs[Lc],Gc=Rs[Gc],l=m+1;
                for(int i=0;i<4;++i)
                    for(int j=1;j<=ct[i];++j)
                        use[i][j]=Rs[use[i][j]];
            }
        }
        printf("%d\n",B[l]);
    }
}

int main() {
    using namespace Tree;
    read(N),read(Q);
    for(int i=1;i<=N;++i) read(A[i]),B[++cnt]=A[i];
    for(int i=1,u,v;i< N;++i) 
        read(u),read(v),Add(u,v);
    for(int i=1;i<=Q;++i) {
        read(q[i].k),read(q[i].a),read(q[i].b);
        if(!q[i].k) B[++cnt]=q[i].b;
    }

    std::sort(B+1,B+cnt+1);
    cnt=std::unique(B+1,B+cnt+1)-B-1;

    tot=0,Dfsa(1,0),Dfsb(1,1);

    for(int i=1;i<=Q;++i) {
        if(q[i].k) RQuery(q[i].a,q[i].b,q[i].k);
        if(!q[i].k) {
            TModify(pl[q[i].a],en[q[i].a]+1,Hash(A[q[i].a]),-1);
            TModify(pl[q[i].a],en[q[i].a]+1,Hash(A[q[i].a]=q[i].b),1);
        }
    }
    return 0;
}
Etta19
关注
专栏目录
BZOJ1146: [CTSC2008]网络管理Network
Don't fake it till you made it
12-19 2238
。。。我居然调试了一个下午　　因为一个else　一个if。。。。 果然自己太弱 听Claris说这一题可以转化为DFS序然后容斥可以直接变成logn*logn*n 只能膜拜 我的是logn*logn*logn*logn*n 然后Jrmz说，这还不如暴力。。。。。 反正就是很普通的一道树剖  然后在链上找k大值用树套树  由于只会外层线段树维护区间的写法  于是就打了3个log的 #in
[BZOJ1146]CTSC2008网络管理|树上带修改K大
Tag_king的专栏
05-04 826
树上带修改K大，太可怕。。写了树链剖分+线段树套平衡树+二分和dfs序+主席树两种，每种都是写+调试花了将近5个小时！！我实在是太弱了。。 1.   树链剖分+线段树套平衡树+二分 最显然的做法了，没啥好多说的，不过写起来真是麻烦（我太弱）， 一不小心就会把线段树和平衡树的节点的域弄混，犯了超级多傻逼错误。。写这题的时候还把自己树链剖分的风格改了一下，以前的实在是太麻烦了。。查询的时候二分答
bzoj1146
weixin_34405557的博客
12-03 97
这是一道无比繁琐的题目话说这道题使我第一次练dfs序，比较感动；首先dfs序就是在dfs过程中按照访问的顺序给每个点标上两个“时间戳”一个是第一次访问到点i时的时间戳c[i]，一个是访问完以i为根时的时间戳cc[i]根据c[i]，我们就可以将树变成序列，并且以i为根的子树，是序列上连续的一段当进行单点修改时，我们可以用树状数组前缀和维护树上的点到根路径上所有点的修改情况和；比如当点i修改时（比如+...
bzoj 1146 网络管理Network (CDQ 整体二分 + 树刨）
dengpangbu3703的博客
05-03 100
题目传送门 题意：求树上路径可修改的第k大值是多少。 题解：CDQ整体二分+树刨。 每一个位置上的数都会有一段持续区间 根据CDQ拆的思维，可以将这个数拆成出现的时间点和消失的时间点。 然后通过整体二分第k大思路 + 树炮询问路径上出现点的个数就好了。 说一下整体二分的思路。 先假设第k大的值是mid， 然后按照时间顺序，出现一个数<=mid标记这个数的位置为1...
BZOJ 1146 网络管理Network（树链剖分+BST）
weixin_33733810的博客
01-08 118
题目链接：http://61.187.179.132/JudgeOnline/problem.php?id=1146 题意：给出一棵树，每个节点有一个权值。两种操作：（1） 修改某个节点的权值；（2）询问a到b路径上第K大的权值。 思路：首先，DFS两次得到树链（重新标号，一个树链上的节点的标号连续）。建立线段树，再为线段树每个节点建立一棵BST。（1）修改时，在线段树上依次向下修改，并且到达...
【BZOJ】[CTSC2008]网络管理Network-线段树套Treap
远行客
04-29 193
传送门：BZOJ1146-网络管理 题意 M公司是一个非常庞大的跨国公司，在许多国家都设有它的下属分支机构或部门。为了让分布在世界各地的N个部门之间协同工作，公司搭建了一个连接整个公司的通信网络。该网络的结构由N个路由器和N-1条高速光缆组成。 每个部门都有一个专属的路由器，部门局域网内的所有机器都联向这个路由器，然后再通过这个通信子网与其他部门进行通信联络。该网络结构保证网络中的任...
黑科技知识
Yu Gi Oh!
02-28 899
前言 这里记录&amp;amp;amp;总结一些平常 OIOIOI 竞赛中并不是很常用的毒瘤玩意。 黑科技 黑科技数据结构 1. 李超线段树 一种线段树维护某一类信息的方法。 支持区间加入一次函数,询问区间的一次函数最值。 修改复杂度为 O(log2n)O(log^2n)O(log2n) , 如果是全局加入就是O(log&amp;amp;nbsp;n)O(log\ n)O(log&amp;amp;nbsp;n) 查询复杂度为 O(log&amp;amp;nbs
【暖*墟】 #数据结构进阶# 主席树超详细解释
flora715的博客
08-23 319
主席树【可持久化线段树/函数式线段树/n棵线段树】          目录 一. 概念理解 1.求所有数字中的第k大数？ 2.求任意一段区间 [ L , r ]中的第k大数？ 3.会不会空间超限？ 超级详细的实现过程分析【戳我戳我qwq】 二. 例题演练 1 【主席树】第K小的数Ⅰ（caioj1441） 2 【主席树】第K小的数Ⅱ（caioj1442） 3 【主席树】第K小的数...
BZOJ 1146: [CTSC2008]网络管理Network 树链剖分 树状数组套主席树/线段树套平衡树
BlackJack
07-30 819
1146: [CTSC2008]网络管理Network Time Limit: 50 Sec  Memory Limit: 256 MB Submit: 3826  Solved: 1123 [Submit][Status][Discuss] Description 　　M公司是一个非常庞大的跨国公司，在许多国家都设有它的下属分支机构或部门。为了让分布在世界各地的N个部门之间协同工作
BZOJ 1146 CTSC2008网络管理
Rayment的博客
04-28 252
Problem BZOJ权限题。。 良心洛谷 Solution 话说刚开始写了个链剖，发现复杂度是O(nlog3n)O(nlog3n)O(nlog^3n)，有点方就全删了，后来题解说连log^4的splay都A掉了。 然后写了个树上主席树，发现复杂度搞错了，又重写了，才改成现在这个样子。。荒废了一上午qwqqq 说正经的吧，就是动态查询路径上权值第k大。 首先我们考虑树上主席树，那么...
[BZOJ1146][CTSC2008]网络管理Network（树状数组套线段树）
女装的你，如此好看！
08-06 217
Address https://www.lydsy.com/JudgeOnline/problem.php?id=1146 Solution 先当树是一个序列，回顾如何求序列区间第 kkk 大 + 单点修改。 维护 nnn 棵动态开点权值线段树，第 iii 棵存序列前 iii 个元素的信息。 单点修改在权值线段树上就是单点减一和单点加一。 于是我们要把第 iii 棵到第 nnn 棵...
【BZOJ1146】网络管理（主席树，树状数组）
小蒟蒻yyb的博客
02-05 235
题面BZOJ权限题，洛谷题面题解树上带修改主席树 貌似和Count On A TreeCount\ On\ A\ Tree那题很相似呀 只需要套上一个树状数组来维护修改好就好了 但是记住是用dfsdfs来记录主席树的标号 一定不要搞错了 每一次修改只会影响他子数的值 而在dfsdfs序上就是连续的一段 美滋滋的做完了#include<iostream> #include<cstdio>
[bzoj1146][CTSC2008]网络管理Network（dfs序+树状数组套主席树）
玫葵之蝶
10-25 419
再发一波福利，还是老规矩，不许说啊。 传送门 其实就是搞下来dfs序，然后差分 具体细节自己想想怎么处理 然后就是这题最恶心的空间 我死活卡在257MB 然后我就放弃卡 正规地先建一棵静态，然后修改在dfs序上改 这样就是O(nlogn+m(update)log2n)O(nlogn+m(update)log^2n)了 所以只开了89MB 代码：#include<cstdio> #
bzoj1146 [CTSC2008]网络管理（树上主席树，树状数组套动态加点线段树）
Icefox的博客
02-26 357
给定一棵树，查询路径第k大值，带修改。 就是bzoj2588+bzoj3196 树上建主席树。然后对于修改，修改点x的权值，只会对x的子树有影响，而x的子树在dfs序上是连续的一段in[x],out[x]，就相当于区间修改，我们利用差分+树状数组来维护，另建bit+动态加点线段树来维护。 树状数组套动态加点线段树内存究竟怎么算.jpg???能开多大是多大好了，反正是要比logn^2小很多？这样
bzoj1146 [CTSC2008]网络管理Network
Elijahqi
02-27 228
http://www.elijahqi.win/2018/02/27/bzoj1146/ Description 　　M公司是一个非常庞大的跨国公司，在许多国家都设有它的下属分支机构或部门。为了让分布在世界各地的N个 部门之间协同工作，公司搭建了一个连接整个公司的通信网络。该网络的结构由N个路由器和N-1条高速光缆组成。 每个部门都有一个专属的路由器，部门局域网内的所有机器都联向这个路由...
【BZOJ1146】网络管理（整体二分）
小蒟蒻yyb的博客
02-05 367
题面良心洛谷，有BZOJ权限题题解要看树套树的戳这里毕竟是：智商不够数据结构来补所以， 我们来当一回智商够的选手听说主席树的题目大部分都可以整体二分这题丢进去整体二分就行了 只需要查询树上贡献的前缀和 但是，对于这种带修改的 不能够直接修改 每一个修改操作必须拆成两个： 一个删掉原来的修改，一个加入现在的修改 否则就会重复计算贡献从而gggg#include<iostream> #in
[bzoj1146]网络管理
weixin_38168173的博客
08-12 111
发现是链上的问题，所以树链剖分发现要查询第k大，因为第k大不支持合并，所以要二分答案二分答案后相当于询问一些区间内大于某数的数个数，直接线段树套平衡树即可时间复杂度$o(nlog^{4}_n)$（跟$o(n^{2})$有什么区别）可以卡过 1 #include<bits/stdc++.h> 2 using namespace std; 3 #defi...
【BZOJ1146】网络管理，整体二分
xiaoyimi的博客
06-03 782
.
等差数列与数据结构——线段树、树状数组解析
"本资源是一份关于BZOJ算术天才⑨与等差数列问题的线段树和树状数组应用的课件，主要针对信息竞赛和OI选手，涵盖了线段树和树状数组的基本概念、优势及在解决实际问题中的应用策略。标签涉及信息竞赛、OI、线段树、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值