bzoj1455: 罗马游戏 + bzoj2809: Dispatching（可并堆）

昨天看了可并堆是什么，写的是左偏树

大概就是一棵树

1、有左偏性质，即当前根到左叶子节点距离比到右叶子节点距离大

2、有堆性质，堆顶关键字比子树关键字小

合并两个堆的时候，关键字大的插入到关键字小的那堆的右子树中，右子树的深度大于左子树时交换两者以维持左偏性质。

堆中个数太多的时候，pop堆顶的元素x

具体是合并左右两个子树后返回新的堆顶元素y，清除完x的信息后root[x]指向y

bzoj1455：用并查集合并团，用可并堆维护团中最小的人。

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 using namespace std;
 ;
 int n,m,v[maxn],vis[maxn],fa[maxn],l[maxn],r[maxn],a,b,d[maxn];
 ];

 int find(int x){
     return (fa[x]==x)?x:fa[x]=find(fa[x]);
 }

 int merge(int x, int y){
     if (!x || !y) return x+y;
     if (v[x]>v[y]) swap(x,y);  //保证堆顶最小
     r[x]=merge(r[x],y);
     if (d[r[x]]>d[l[x]]) swap(l[x],r[x]);
     d[x]=d[r[x]]+;
     return x;
 }

 int main(){
     scanf("%d", &n);
     ; i<=n; i++) scanf("%d", &v[i]);
     scanf(]=-;
     ; i<=n; i++) fa[i]=i;
     ; i<=m; i++){
         scanf("%s", s);
         ]=='M'){
             scanf("%d%d", &a, &b);
             if (vis[a] || vis[b]) continue;
             int fx=find(a), fy=find(b);
             if (fx!=fy) fa[fx]=fa[fy]=merge(fx,fy); // 合并从堆顶开始合并
         }else{
             scanf("%d", &a);
             ");
             else{
                 ;// printf("  %d\n", fx);
                 printf("%d\n", v[fx]);
                 fa[fx]=merge(l[fx],r[fx]);
                 fa[fa[fx]]=fa[fx];
             }
         }
     }
     ;
 }

bzoj2809：DFS一遍，从叶子节点开始向上递归，到一个节点，可并堆维护当前子树中满足预算的最多人数，然后用当前子树更新答案。具体是每个节点都插入，超出预算就pop最大花费的人直到满足预算

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #define LL long long
 using namespace std;
 ;
 struct node{
     int to,next;
 }e[maxn];
 struct heap{
     int l,r;
     LL val;
 }t[maxn];
 ,head[maxn];
 LL v[maxn],w[maxn],ans,sum[maxn],add[maxn];

 void insert(int u, int v){
     e[++tot].to=v; e[tot].next=head[u]; head[u]=tot;
 }

 int merge(int x, int y){
     if (!x || !y) return x+y;
     if (t[x].val<t[y].val) swap(x,y);
     t[x].l=merge(t[x].l,y);
     swap(t[x].l,t[x].r);
     return x;
 }

 void Pop(int x){
     int rt=root[x];
     root[x]=merge(t[rt].l,t[rt].r);
     sum[x]--; add[x]-=t[rt].val;
     t[rt].l=t[rt].r=t[rt].val=;
 }

 void dfs(int u){
     add[u]=sum[u]=;
     for (int i=head[u],vv; i; i=e[i].next){
         dfs(vv=e[i].to);
         add[u]+=add[vv]; sum[u]+=sum[vv];
         root[u]=merge(root[u],root[vv]);
         while (add[u]>m) Pop(u);
     }
     add[u]+=v[u]; sum[u]++;
     t[u]=(heap){,,v[u]};
     root[u]=merge(root[u],u);
     while (add[u]>m) Pop(u);
     ans=max(ans,sum[u]*w[u]);
 }

 int main(){
     scanf("%d%d", &n, &m); int s;
     ; i<=n; i++){
         int x;
         scanf("%d%lld%lld", &x, &v[i], &w[i]);
         insert(x,i); if (!x) s=i;
     }
     dfs(s);
     printf("%lld\n", ans);
     ;
 }