左偏树初步 bzoj2809 & bzoj4003

　　看着百度文库学习了一个。

　　总的来说，左偏树这个可并堆满足 堆的性质 和 左偏 性质。

　　bzoj2809: [Apio2012]dispatching

　　　　把每个忍者先放到节点上，然后从下往上合并，假设到了这个点 总值 大于 预算，那么我们把这个 大根堆 的堆顶弹掉就好了，剩下的就是可合并堆。

　　　　感谢prey :)

　　　　

 #include <bits/stdc++.h>
 #define rep(i, a, b) for (int i = a; i <= b; i++)
 #define drep(i, a, b) for (int i = a; i >= b; i--)
 #define REP(i, a, b) for (int i = a; i < b; i++)
 #define mp make_pair
 #define pb push_back
 #define clr(x) memset(x, 0, sizeof(x))
 #define xx first
 #define yy second
 using namespace std;
 typedef pair<int, int> pii;
 typedef long long ll;
 const int inf = 0x3f3f3f3f;
 const ll INF = 0x3f3f3f3f3f3f3f3fll;
 //************************************************

 const int maxn = ;

 struct Ed {
     int u, v, nx; Ed() {}
     Ed(int _u, int _v, int _nx) :
         u(_u), v(_v), nx(_nx) {}
 } E[maxn];
 int G[maxn], edtot;
 void addedge(int u, int v) {
     E[++edtot] = Ed(u, v, G[u]);
     G[u] = edtot;
 }

 int pre[maxn], C[maxn], L[maxn], son[maxn];
 struct node {
     int key, dis, l, r, sz;
 } heap[maxn];
 int ndtot;

 int root[maxn];
 ll M;
 template <typename T> inline void MaxT (T &a, const T b) { if (a < b) a = b; }
 ll ans = -;
 int merge(int x, int y) {
     if (!x) return y;
     if (!y) return x;
     if (heap[x].key < heap[y].key) swap(x, y);
     heap[x].r = merge(heap[x].r, y);
     heap[x].sz = heap[heap[x].l].sz + heap[heap[x].r].sz + ;
     if (heap[heap[x].l].dis < heap[heap[x].r].dis) swap(heap[x].l, heap[x].r);
     heap[x].dis = heap[heap[x].r].dis + ;
     return x;
 }
 ll solve(int x) {
     ll sum = C[x];
     heap[root[x] = ++ndtot] = (node) {C[x], , , , };
     for (int i = G[x], y; i; i = E[i].nx) {
         sum += solve(y = E[i].v);
         root[x] = merge(root[x], root[y]);
     }
     while (sum > M) sum -= heap[root[x]].key, root[x] = merge(heap[root[x]].l, heap[root[x]].r);
     MaxT(ans, 1ll * heap[root[x]].sz * L[x]);
     return sum;
 }

 int main() {
     int n; scanf("%d%lld", &n, &M);
     int rt;
     rep(i, , n) {
         scanf("%d%d%d", pre + i, C + i, L + i);
         son[pre[i]]++;
         if (pre[i] == ) rt = i;
         addedge(pre[i], i);
     }
     solve(rt);
     printf("%lld\n", ans);
     return ;
 }

　　bzoj4003: [JLOI2015]城池攻占

　　　　堆上打个lazytag即可，可以表示成 tag_a * x + tag_b 的形式，标记的合并也很简单，tag_a2 * (tag_a1 * x + tag_b1) + tag_b2，乘开就好。

 #include <bits/stdc++.h>
 #define rep(i, a, b) for (int i = a; i <= b; i++)
 #define drep(i, a, b) for (int i = a; i >= b; i--)
 #define REP(i, a, b) for (int i = a; i < b; i++)
 #define mp make_pair
 #define pb push_back
 #define clr(x) memset(x, 0, sizeof(x))
 #define xx first
 #define yy second
 using namespace std;
 typedef pair<int, int> pii;
 typedef long long ll;
 const int inf = 0x3f3f3f3f;
 const ll INF = 0x3f3f3f3f3f3f3f3fll;
 //************************************************

 const int maxn = ;

 struct Ed {
     int u, v, nx; Ed() {}
     Ed(int _u, int _v, int _nx) :
         u(_u), v(_v), nx(_nx) {}
 } E[maxn];
 int G[maxn], edtot;
 void addedge(int u, int v) {
     E[++edtot] = Ed(u, v, G[u]);
     G[u] = edtot;
 }

 struct node {
     int dis, l, r, sz;
     ll key, tag_a, tag_b;
     int id;
 } heap[maxn];
 int ndtot;

 ll hp[maxn], A[maxn], V[maxn];
 int pre[maxn], root[maxn];
 ll S[maxn], C[maxn];

 void Push_down(int x) {
     if (heap[x].tag_a ==  && heap[x].tag_b == ) return;
     int l = heap[x].l, r = heap[x].r;
     heap[l].tag_a *= heap[x].tag_a, heap[l].tag_b = heap[l].tag_b * heap[x].tag_a + heap[x].tag_b;
     heap[r].tag_a *= heap[x].tag_a, heap[r].tag_b = heap[r].tag_b * heap[x].tag_a + heap[x].tag_b;
     heap[l].key = heap[l].key * heap[x].tag_a + heap[x].tag_b;
     heap[r].key = heap[r].key * heap[x].tag_a + heap[x].tag_b;
     heap[x].tag_a = , heap[x].tag_b = ;
     return;
 }

 int merge(int x, int y) {
     if (!x) return y;
     if (!y) return x;
     Push_down(x), Push_down(y);
     if (heap[x].key > heap[y].key) swap(x, y);
     heap[x].r = merge(heap[x].r, y);
     heap[x].sz = heap[heap[x].l].sz + heap[heap[x].r].sz + ;
     if (heap[heap[x].l].dis < heap[heap[x].r].dis) swap(heap[x].l, heap[x].r);
     heap[x].dis = heap[heap[x].r].dis + ;
     return x;
 }

 int Stop[maxn], Peo[maxn];
 int dep[maxn];
 void solve(int x) {
     for (int i = G[x], y; i; i = E[i].nx) {
         dep[y = E[i].v] = dep[x] + ;
         solve(y);
         root[x] = merge(root[x], root[y]);
     }
     Push_down(root[x]);
     while (root[x] && heap[root[x]].key < hp[x]) {
         Push_down(root[x]);
         Stop[heap[root[x]].id] = x;
         Peo[x]++;
         root[x] = merge(heap[root[x]].l, heap[root[x]].r);
     }
     if (root[x]) {
         Push_down(root[x]);
         if (A[x] == ) heap[root[x]].tag_b = V[x], heap[root[x]].key += V[x];
         else heap[root[x]].tag_a = V[x], heap[root[x]].key *= V[x];
     }
 }

 int main() {
     int n, m; scanf("%d%d", &n, &m);
     rep(i, , n) scanf("%lld", hp + i);
     rep(i, , n) {
         scanf("%d%lld%lld", pre + i, A + i, V + i);
         addedge(pre[i], i);
     }
     rep(i, , m) {
         scanf("%lld%lld", S + i, C + i);
         heap[++ndtot] = (node) {, , , , S[i], , , i};
         root[C[i]] = merge(root[C[i]], ndtot);
     }
     solve();
     rep(i, , n) printf("%d\n", Peo[i]);
     rep(i, , m) printf("%d\n", Stop[i] ? dep[C[i]] - dep[Stop[i]] : dep[C[i]] + );
 }