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

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

大概就是一棵树

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

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

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

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

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

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

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

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]]+1;
    return x;
}

int main(){
    scanf("%d", &n);
    for (int i=1; i<=n; i++) scanf("%d", &v[i]);
    scanf("%d", &m); d[0]=-1;
    for (int i=1; i<=n; i++) fa[i]=i;
    for (int i=1; i<=m; i++){
        scanf("%s", s);
        if (s[0]=='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);
            if (vis[a]) puts("0");
            else{
                int fx=find(a); vis[fx]=1;// printf("  %d
", fx);
                printf("%d
", v[fx]);
                fa[fx]=merge(l[fx],r[fx]);
                fa[fa[fx]]=fa[fx];
            }
        }
    }
    return 0;
}

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

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define LL long long
using namespace std;
const int maxn = 100010;
struct node{
    int to,next;
}e[maxn];
struct heap{
    int l,r;
    LL val;
}t[maxn];
int n,m,root[maxn],tot=1,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=0;
}

void dfs(int u){
    add[u]=sum[u]=0;
    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){0,0,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;
    for (int i=1; 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
", ans);
    return 0;
}