[Apio2012][Treap]派遣

原题地址

题意：在树中找到一个点i，并且找到这个点子树中的一些点组成一个集合，使得集合中的所有点的c之和不超过M，且Li*集合中元素个数和最大。

现在有三种做法

很显然的贪心策略：对于每个点，我们把每个以他为代表的子树里的所有点，从小到大排好序。然后一直选小的，直到不满足条件为止。

我们从叶子到根进行合并即可。

法一：

平衡树，对于本蒟蒻来说，当然选择treap了，对于两个将被合并的treap，我们不能保证它们相对有序，因此只能使用启发式合并，即每次合并时把小的treap中的元素一个一个塞到大的里。复杂度 ： 由于是把小到塞到大的里，那么那棵小的子树的大小肯定至少变为原来的两倍，因此对于每个元素，至多合并logn次，一共合并nlogn次，每次合并复杂度logn。因此全局合并的复杂度nlog方。我还小小的优化了一下：对于每个即将被合并的节点，由于合并后只会选总和不超过m的那么多个节点，所以当前被合并的节点也只有可能总和不超过m的前面的节点被合并后的节点利用，因此我们还可以在每个节点更新了答案之后，分裂一下，使它里面元素的总和恰好小于等于m。

上代码

#include<cstdio>#include<algorithm>#include<cstring>#include<cstdlib>#include<iostream>#include<string>#include<cmath>#include<cctype>const int N = 1e5 + 9;int n,m,c[N],l[N];struct Edge {int to;Edge *next;Edge () {}Edge (int to,Edge *next) : to(to),next(next) {}}ME[N],*Po = ME,*head[N];void AddEdge (int u,int v) {head [u] = new (Po++) Edge (v, head[u]);}struct Treap {int data, size, hr; long long sum;Treap *l, *r;Treap (int data, Treap *fl) : data(data),size(1),hr(rand()),sum(data),l(fl),r(fl) {}Treap () {}void update() { size = l -> size + r -> size + 1; sum = l -> sum + r -> sum + data; }}*Null,*root[N],meme[N],*pool = meme;Treap *newnode (int xxx) {return new (pool++) Treap (xxx, Null);}Treap *Merge (Treap *A, Treap *B) {if (A == Null) return B;if (B == Null) return A;if (A -> hr > B -> hr) {B -> l = Merge (A, B -> l);B -> update ();return B;} else {A -> r = Merge (A -> r, B);A -> update ();return A;}}using std :: pair;typedef pair <Treap*, Treap*> Droot;Droot Split_Rank (Treap *x, int k) {if (x == Null) return Droot (Null, Null);Droot y;if (x -> l -> size >= k) {y = Split_Rank (x -> l, k);x -> l = y . second;x -> update ();y . second = x;} else {y = Split_Rank (x -> r, k - x -> l -> size - 1);x -> r = y . first;x -> update ();y . first = x;}return y;}Droot Split_Data (Treap *x, int k) {if (x == Null) return Droot (Null, Null);Droot y;if (x -> data >= k) {y = Split_Data (x -> l, k);x -> l = y . second;x -> update ();y . second = x;} else {y = Split_Data (x -> r, k);x -> r = y . first;x -> update ();y . first = x;}return y;}// ÆäʵÄØ£¬ ÎÞÂÛÊǶѻ¹ÊÇƽºâÊ÷£¬Æô·¢Ê½¶¼ÊÇlognµÄ void Insert (Treap *&gen, Treap* xxx) {static Droot clc1;clc1 = Split_Data (gen, xxx -> data);gen = Merge (clc1 . first, Merge (xxx, clc1.second));}int Ran (Treap *x, int& pac) {if (x == Null) return 0; int sum;if (x -> l -> sum <= pac) pac -= x -> l -> sum, sum = x -> l -> size;else sum = Ran (x -> l, pac);if (pac >= x -> data) pac -= x -> data, ++sum;if (pac >= x -> data) sum += Ran (x -> r, pac);return sum;}long long ans;int jl;Treap *u,*v;Droot clc1;void Dfs_Merge (int x) {if(head[x]) {for (Edge *now = head[x]; now; now = now -> next) {Dfs_Merge (now -> to);u = root[x]; v = root[now -> to]; // ¿¼ÂǺϲ¢uºÍv...if (u -> size > v -> size) std :: swap (u, v); // È·±£uС£¬v´ó while (u -> size) {clc1 = Split_Rank (u, 1);u = clc1 . second;Insert (v, clc1.first);}root[x] = v;}Insert (root[x],newnode(c[x]));int M = m;int ran = Ran (root[x], M);root[x] = Split_Rank (root[x],ran) . first;ans = std :: max (ans, 1ll * ran * l[x]);} else {root [x] = newnode (c[x]);ans = std :: max (ans, 1ll * l[x]);}}void Init () {Null = new Treap (); Null -> size = 0;int b;scanf ("%d%d",&n,&m);for (int i=1;i<=n;++i) {scanf ("%d%d%d",&b,c+i,l+i);AddEdge (b,i);root[i] = Null;}}int main () {Init ();Dfs_Merge (1);printf("%lld\n",ans);return 0;}

法二：

很显然的，还可以使用左偏树秒杀，左偏树每次合并不必保证相对有序，所以合并总复杂度nlogn的。。。

但有个问题，如何求左偏树的前k个的大小和呢？

这是个极其蛋疼的问题，所以我们可以转化一下，对于每个左偏树内节点，记下它所在子树的和的大小，把当前的左偏树建成一个小根堆(大的在最上面)，不断地弹出，直到元素之和小于等于m。对于每个结点，最多被弹出一次，每次logn 所以弹出的总复杂度是nlogn。。

整个程序的复杂度就是nlogn辣。

上代码

#include<cstdio>#include<cstring>#include<string>#include<cstdlib>#include<iostream>#include<algorithm>#include<cctype>#include<cmath>const int N = 1e5 + 9;int n, m, c[N], l[N];long long ans;struct Edge {int to;Edge *next;Edge () {}Edge (int to, Edge *next) : to(to),next(next) {}}*head[N],Me[N],*Po = Me;void AddEdge (int u, int v) {head[u] = new (Po++) Edge (v, head[u]);}struct LT {int size, dist, data; long long sum;LT *l, *r;LT () {}LT (int data, LT *fl) : size(1),dist(0),data(data),sum(data),l(fl),r(fl) {}void update () { sum = l -> sum + r -> sum + data; dist = r -> dist + 1; size = l -> size + r -> size + 1; }}*Null, *root[N], meme[N], *pool = meme;LT *newnode (int xxx) {return new (pool++) LT (xxx, Null);}LT *Merge (LT *A, LT *B) {if (A == Null) return B;if (B == Null) return A;if (A -> data < B -> data) std :: swap (A, B);A -> r = Merge (A -> r, B);if (A -> r -> dist > A -> l -> dist) std :: swap (A -> l, A -> r);A -> update ();return A;}void Dfs_Merge (int x) {for (Edge *now = head[x]; now; now = now -> next) {Dfs_Merge (now -> to);root[x] = Merge (root[x], root[now -> to]);}root[x] = Merge (root[x], newnode(c[x]));while (root[x] -> sum > m) {root[x] = Merge (root[x] -> l,root[x] -> r);}ans = std :: max (ans , 1ll * root[x] -> size * l[x]);}void Init () {Null = new LT(); Null -> size = Null -> dist = Null -> sum = Null -> data = 0;scanf ("%d%d",&n,&m);int ooo;for (int i = 1; i<= n; ++ i) scanf ("%d%d%d",&ooo,&c[i],&l[i]), AddEdge (ooo, i) , root[i] = Null;}int main () {Init ();Dfs_Merge (1);printf ("%lld\n",ans);return 0;}

法三 莫队加权值分块，根号+根号，暴力一加一

首先我们建出dfs序，这是树形转线性的一种方法。

那么题目就变为查询很多段连续区间，求所有区间中总和加上小于等于m的点的最大个数。 (可能表达地不是很好)

那么就可以用到莫队来处理询问了。

我们发现，最多有1e5个点，因此我们可以离散化，然后权值分块，（这里的权值就是指块状每个节点相当于一个值有多少个）

每次查询根号n，移动总共n根号n，总复杂度 n 根号 n