我懒死了

过于棘手

但这题真的很水的说

毕竟写啥都能过

常见思路:

①:由于不强制在线,所以重新编号之后线段树维护

②:用各种可以高速合并的数据结构,比如可并堆,可并平衡树啥的

讲一种无脑算法:

对于$F1$,并查集乱搞

对于$F2$,用可并堆维护连通块里的值,并维护对应的时间,如果堆顶访问到旧的值直接抛出

对于$F3$,用全局堆维护每个连通块的最大值的集合并维护对应的时间,如果堆顶访问到旧的值直接抛出

$A1$:单点修改时在所在可并堆里插入一个新的,维护修改时间,同时在全局堆里插入一个新的该可并堆的最大值

$A2$:在堆上打tag,在全局堆中插入新的最大值

$A3$:维护一个全局变量

$U$:略

好气啊将近二百行可并堆写的一点问题没有结果十多行并查集出了三处锅...

 #include<cstdio>
 #include<queue>
 #include<algorithm>
 using std::max;
 using std::priority_queue;
 using std::swap;
 ;
 int n,v[N],del[N],Del;
 ];

 int lta[N],ltb[N];
 struct shino
 {
     int id,v,t;
     shino(){}
     shino(int a,int b,int c){id=a,v=b,t=c;}
     bool friend operator < (shino x,shino y){return x.v<y.v;}
 }g;
 struct merheap
 {
     ],tag[N<<],son[N<<][],fa[N<<],kr,yop[N<<],rt[N<<];
     shino el[N<<];
     int find(int x)
     {
         if(fa[x]==x) return x;
         else return fa[x]=find(fa[x]);
     }
     void fuckdown(int x)
     {
         if(tag[x])
         {
             ];
             if(k){el[k].v+=tag[x];tag[k]+=tag[x];}
             k=son[x][];
             if(k){el[k].v+=tag[x];tag[k]+=tag[x];}
             tag[x]=;
         }
     }
     int makenew(shino sn)
     {
         kr++;
         el[kr]=sn;
         fa[kr]=kr;
         return kr;
     }
     int merge(int x,int y)
     {
         if(!x) return y;
         if(!y) return x;
         fuckdown(x);
         fuckdown(y);
         if(el[x]<el[y]) swap(x,y);
         son[x][]=merge(son[x][],y);
         fa[son[x][]]=x;
         ]]<dis[son[x][]]) swap(son[x][],son[x][]);
         dis[x]=dis[son[x][]]+;
         return x;
     }
     void push(int x,shino ei)
     {
         int tmp=makenew(ei);
         int xx=find(x);
         rt[x]=merge(xx,tmp);
     }
     void pop(int x)
     {
         int xx=find(x);
         fuckdown(xx);
         ],son[xx][]);
         fa[xx]=tmp;
         ]) fa[son[xx][]]=tmp;
         ]) fa[son[xx][]]=tmp;
         rt[x]=tmp;
     }
     shino top(int x)
     {
         x=find(x);
         return el[x];
     }
     void update(int x)
     {
         int xx=find(x);
         while(xx)
         {
             xx=find(xx);
             g=top(xx);
             if(g.t!=lta[g.id]) pop(xx);
             else break;
         }
     }
     void add(int x,int vi)
     {
         int xx=find(x);
         el[xx].v+=vi;
         tag[xx]+=vi;
     }
     void init()
     {
         ;i<=n;i++)
         {
             makenew(shino(i,v[i],));
             rt[i]=i;
         }
     }
 }rk;
 int fa[N];
 bool isrt[N];
 void domerge(int x,int y);
 priority_queue<shino> q;
 void find(int x)
 {
     if(fa[x]!=fa[fa[x]]) find(fa[x]),v[x]+=del[fa[x]];
     fa[x]=fa[fa[x]];
 }
 void merge(int x,int y,int tt)
 {
     find(x),find(y);
     int fx=fa[x],fy=fa[y];
     if(fx==fy) return;
     domerge(fx,fy);
     q.push(shino(fy,rk.top(fy).v,tt));
     ltb[fy]=tt;
     fa[fx]=fy;
     del[fx]-=del[fy];
     v[fx]+=del[fx];
     isrt[fx]=;
 }
 void domerge(int x,int y)
 {
     int xx=rk.find(x),yy=rk.find(y);
     int tmp=rk.merge(xx,yy);
     rk.fa[xx]=rk.fa[yy]=rk.rt[y]=tmp;
 }
 void fuckdate()
 {
     while(!q.empty())
     {
         g=q.top();
         if(!isrt[g.id]||g.t!=ltb[g.id]) q.pop();
         else break;
     }
 }

 int main()
 {
     scanf("%d",&n);
     ;i<=n;i++) scanf(;
     int T;
     scanf("%d",&T);
     rk.init();
     ;i<=n;i++) q.push(shino(i,v[i],));
     int xin,yin,vin;
     ;t<=T;t++)
     {
         scanf("%s",op);
         ]=='U')
         {
             scanf("%d%d",&xin,&yin);
             merge(xin,yin,t);
         }]=='A')
         {
             ]==')
             {
                 scanf("%d%d",&xin,&vin);
                 find(xin);
                 v[xin]+=vin;
                 rk.push(fa[xin],shino(xin,v[xin]+del[fa[xin]],t));
                 lta[xin]=t;
                 rk.update(fa[xin]);
                 q.push(shino(fa[xin],rk.top(fa[xin]).v,t));
                 ltb[fa[xin]]=t;
             }]==')
             {
                 scanf("%d%d",&xin,&vin);
                 find(xin);
                 del[fa[xin]]+=vin;
                 rk.add(fa[xin],vin);
                 q.push(shino(fa[xin],rk.top(fa[xin]).v,t));
                 ltb[fa[xin]]=t;
             }else
             {
                 scanf("%d",&vin);
                 Del+=vin;
             }
         }]=='F')
         {
             ]==')
             {
                 scanf("%d",&xin);
                 find(xin);
                 printf("%d\n",v[xin]+del[fa[xin]]+Del);
             }]==')
             {
                 scanf("%d",&xin);
                 find(xin);
                 rk.update(fa[xin]);
                 printf("%d\n",rk.top(fa[xin]).v+Del);
             }else
             {
                 fuckdate();
                 g=q.top();
                 printf("%d\n",g.v+Del);
             }
         }
     }
     ;
 }

巨佬您txdy

题外话:你这题解也太水了吧

rkk:因为确实水死了啊...都快成板子了...

[SCOI2011]棘手的操作(可并堆/并查集/线段树)的更多相关文章

  1. 【bzoj2333】 [SCOI2011]棘手的操作 可并堆+lazy标记

    2016-05-31  21:45:41 题目:http://www.lydsy.com/JudgeOnline/problem.php?id=2333 (学习了黄学长的代码 有如下操作: U x y ...

  2. BZOJ 2333: [SCOI2011]棘手的操作 可并堆 左偏树 set

    https://www.lydsy.com/JudgeOnline/problem.php?id=2333 需要两个结构分别维护每个连通块的最大值和所有连通块最大值中的最大值,可以用两个可并堆实现,也 ...

  3. 【bzoj2333】[SCOI2011]棘手的操作 可并堆+STL-set

    UPD:复杂度是fake的...大家还是去写启发式合并吧. 题目描述 有N个节点,标号从1到N,这N个节点一开始相互不连通.第i个节点的初始权值为a[i],接下来有如下一些操作: U x y: 加一条 ...

  4. [bzoj2333] [SCOI2011]棘手的操作 (可并堆)

    //以后为了凑字数还是把题面搬上来吧2333 发布时间果然各种应景... Time Limit: 10 Sec  Memory Limit: 128 MB Description 有N个节点,标号从1 ...

  5. BZOJ 2333 [SCOI2011]棘手的操作 (可并堆)

    码农题.. 很显然除了两个全局操作都能用可并堆完成 全局最大值用个multiset记录,每次合并时搞一搞就行了 注意使用multiset删除元素时 如果直接delete一个值,会把和这个值相同的所有元 ...

  6. bzoj 2333 [SCOI2011]棘手的操作 —— 可并堆

    题目:https://www.lydsy.com/JudgeOnline/problem.php?id=2333 稍微复杂,参考了博客:http://hzwer.com/5780.html 用 set ...

  7. 【BZOJ 2333 】[SCOI2011]棘手的操作(离线+线段树|可并堆-左偏树)

    2333: [SCOI2011]棘手的操作 Description 有N个节点,标号从1到N,这N个节点一开始相互不连通.第i个节点的初始权值为a[i],接下来有如下一些操作: U x y: 加一条边 ...

  8. 真--可并堆模板--BZOJ2333: [SCOI2011]棘手的操作

    n<=300000个点,开始是独立的,m<=300000个操作: 方法一:单点修改.查询,区间修改.查询?等等等等这里修改是块修改不是连续的啊,那就让他连续呗!具体方法:离线后,每次连接两 ...

  9. 【BZOJ 2333 】[SCOI2011]棘手的操作(离线+线段树)

    2333: [SCOI2011]棘手的操作 Description 有N个节点,标号从1到N,这N个节点一开始相互不连通.第i个节点的初始权值为a[i],接下来有如下一些操作: U x y: 加一条边 ...

随机推荐

  1. MHA高可用 MHA+Keepalive

    MHA高可用 MHA简介 MHA(Master High Availability)目前在MySQL高可用方面是一个相对成熟的解决方案,它由日本DeNA公司youshimaton(现就职于Facebo ...

  2. P5107 能量采集

    传送门 官方题解 话说最后的答案忘记取模了结果连暴力都挂了可海星-- //minamoto #include<bits/stdc++.h> #define R register #defi ...

  3. 大神是怎样用函数式JavaScript计算数组平均值的

    译者按: 有时候一个算法的直观.简洁.高效是需要作出取舍的. 原文: FUNCTIONAL JAVASCRIPT: FIVE WAYS TO CALCULATE AN AVERAGE WITH ARR ...

  4. ibatais.net 连接 mysql 最全配置写法

    1.安装环境: 1.       vs2013 (vs开发工具) 2.       mysql 5.7.10.0 (安装的mysql 数据库版本) https://dev.mysql.com/doc/ ...

  5. USACO Training刷题记录 By cellur925

    Section 1.1 Your Ride Is Here 貌似没啥可说 Greedy Gift Givers 上来就想stl map映射,有两个坑:如果送给别人的人数为0,那么需要特判一下,防止整数 ...

  6. centos 7 添加普通用户

    adduser username username 是你要创建的用户名 passwd username 创建密码,输入个稍微复杂的 usermod -a -G wheel username 将用户加入 ...

  7. Unix\Linux | 总结笔记 |文件系统_shell重定向

    输入重定向< 从文件中获得命令需要的输入数据,适合数据源已经定义好,可重复使用 #显示文件test.txt的内容 cat < tesxt.txt #统计文件test.txt中的行数 单词数 ...

  8. [ZPG TEST 115] 种树【差分约束】

    4. 种树 (trees.pas/c/cpp) [问题描述] 一条街的一边有几座房子.因为环保原因居民想要在路边种些树.路边的地区被分割成块,并被编号为1..n.每个块的大小为一个单位尺寸并最多可种一 ...

  9. jQuery 常见面试题

    一 :Q: What is the difference between .get(), [], and .eq()? A: eq返回原生jQuery对象,截取某些el元素生成Jquery新对象 ge ...

  10. [转]C#委托Action、Action<T>、Func<T>、Predicate<T>

    CLR环境中给我们内置了几个常用委托Action. Action<T>.Func<T>.Predicate<T>,一般我们要用到委托的时候,尽量不要自己再定义一 个 ...