左偏树

左偏树是一个堆，而且是一个可并堆，所以一定有权值的限制

以小根堆为例，那么必须满足节点权值小于左右儿子权值，即val[i]<val[lson[i]] val[i]<val[rson[i]]

为了维护左偏树的时间复杂度，就要设计一些左偏树独有的工具，定义

• 外节点：满足左右儿子至少有一个没有的点
• 距离dis[i]：点$i$到离它最近的一个外节点的距离；特别的，空节点的距离为$-1$，外节点本身距离为$0$

左偏树，树如其名，向左偏的树

也就是说左边要“重一点”，但这个重不是常见的子树大小或者高度，而是我们定义的dis

• 对于左偏树的每个点$i$，满足dis[lson[i]]>=dis[rson[i]]

完全有可能，左儿子只有一个点，右儿子是一条链：不管是左儿子的一个点还是右儿子一条链上的点都符合外节点定义，所以dis都是$0$

考虑由下向上更新距离数组，即dis[i]=min(dis[lson[i]],dis[rson[i]])+1

由于左偏树的性质，右儿子距离一定是小的，所以左偏树的更新直接就是从右儿子处更新

• dis[i]=dis[rson[i]]+1

左偏树特殊距离的定义，就保证了左偏树的时间复杂度

• 节点数为$n$的树，树根的$dis\le \log (n+1)-1$

一个点的距离大于$x$，意味着$x-1$层内都是满二叉树

左偏树的合并(merge)操作

左偏树最重要的，或者说特色，就是它的合并操作

有了以上的理论基础，结合fhq-treap的返回根合并操作，左偏树的合并还是很好写的

struct node { int l, r, val, dis; } t[maxn];
int merge( int x, int y ) {if( ! x or ! y ) return x + y;if( t[x].val > t[y].val ) swap( x, y );t[x].r = merge( t[x].r, y );if( t[t[x].l].dis < t[t[x].r].dis ) swap( t[x].l, t[x].r );t[x].dis = t[t[x].r].dis + 1;return x;
}

int lson[maxn], rson[maxn], val[maxn], dis[maxn];
int merge( int x, int y ) {if( ! x or ! y ) return x + y;if( val[x] < val[y] ) swap( x, y );rson[x] = merge( rson[x], y );if( dis[lson[x]] < dis[rson[x]] ) swap( lson[x], rson[x] );dis[x] = dis[rson[x]] + 1;return x;
}

例题

罗马游戏

luogu 2713

这就是比较板的题了，初始时，把每个士兵当成一个左偏树，合并就是两个士兵的左偏树合并

杀士兵，就是去掉左偏树的根节点，直接合并左右儿子即可

但是怎么找士兵所在的兵团呢？——并查集！

#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 1000005
struct node { int l, r, val, dis; } t[maxn];
bool vis[maxn];
int f[maxn];
int n, m;int find( int x ) { return x == f[x] ? x : f[x] = find( f[x] ); }int merge( int x, int y ) {if( ! x or ! y ) return x + y;if( t[x].val > t[y].val ) swap( x, y );t[x].r = merge( t[x].r, y );if( t[t[x].l].dis < t[t[x].r].dis ) swap( t[x].l, t[x].r );t[x].dis = t[t[x].r].dis + 1;return x;
}int main() {scanf( "%d", &n );t[0].dis = -1;for( int i = 1;i <= n;i ++ ) {scanf( "%d", &t[i].val );f[i] = i;}scanf( "%d", &m );char opt[5]; int i, j;while( m -- ) {scanf( "%s", opt );if( opt[0] == 'M' ) {scanf( "%d %d", &i, &j );if( vis[i] or vis[j] ) continue;i = find( i ), j = find( j );if( i ^ j ) f[j] = f[i] = merge( i, j );}else {scanf( "%d", &i );if( vis[i] ) printf( "0\n" );else {i = find( i );vis[i] = 1;printf( "%d\n", t[i].val );f[i] = f[t[i].l] = f[t[i].r] = merge( t[i].l, t[i].r );/*就算杀了根节点代表的这个士兵也要更新士兵的并查集集合因为可能有些士兵跨过了根节点的左右儿子直接并查集是接在根节点并查集的下面的find的时候是会跳到根节点的并查集点的*/}}}return 0;
}

[Apio2012]dispatching

BZOJ 2809

dfs树从下往上合并

每次丢掉最大的$C_i$即可

同样别忘了并查集

#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
#define maxn 100005
#define int long long
vector < int > G[maxn];
int lson[maxn], rson[maxn], dis[maxn], f[maxn], L[maxn], C[maxn];
int n, m, root;
long long ans;int find( int x ) { return f[x] == x ? x : f[x] = find( f[x] ); }int merge( int x, int y ) {if( ! x or ! y ) return x + y;if( C[x] < C[y] ) swap( x, y );rson[x] = merge( rson[x], y );if( dis[lson[x]] < dis[rson[x]] ) swap( lson[x], rson[x] );dis[x] = dis[rson[x]] + 1;return x;
}pair < int, int > dfs( int u ) {int cnt = 1, sum = C[u];for( auto v : G[u] ) {pair < int, int > son = dfs( v );cnt += son.first, sum += son.second;int x = find( u ), y = find( v );root = f[u] = f[v] = merge( x, y );while( sum > m ) {sum -= C[root], cnt --;f[root] = f[lson[root]] = f[rson[root]] = merge( lson[root], rson[root] );root = f[root];}ans = max( ans, L[u] * cnt );}ans = max( ans, L[u] * cnt );return make_pair( cnt, sum );
}signed main() {scanf( "%lld %lld", &n, &m );for( int i = 1, B;i <= n;i ++ ) {scanf( "%lld %lld %lld", &B, &C[i], &L[i] );G[B].push_back( i );f[i] = i;}dis[0] = -1;dfs( 1 );printf( "%lld\n", ans );return 0;
}

[JLOI2015]城池攻占

luogu 3261

初始时，将每一座城市当成一个左偏树，并把在该城市的士兵在左偏树上完成合并

与上一题一样的，从下往上合并左偏树，把所有儿子的骑士聚集到当前根节点城市

把战斗力不足的扔掉，所以需要小根堆

利用初末城市的深度差，巧妙计算出每个骑士能攻占的城市数量

至于城市对骑士的战斗力影响，一样的整体懒标记，碰到了再下传

#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
#define int long long
#define maxn 300005
vector < int > G[maxn];
struct node { int lson, rson, dis, val, add, mul; }t[maxn];
int root[maxn], h[maxn], a[maxn], v[maxn], c[maxn];
int ans1[maxn], ans2[maxn], dep[maxn];
int n, m;void modify( int x, int mul, int add ) {if( ! x ) return;t[x].val *= mul;t[x].val += add;t[x].mul *= mul;t[x].add *= mul;t[x].add += add;
}void pushdown( int x ) { if( ! x ) return;modify( t[x].lson, t[x].mul, t[x].add );modify( t[x].rson, t[x].mul, t[x].add );t[x].mul = 1;t[x].add = 0;
}int merge( int x, int y ) {if( ! x or ! y ) return x + y;pushdown( x );pushdown( y );if( t[x].val > t[y].val ) swap( x, y );t[x].rson = merge( t[x].rson, y );if( t[t[x].lson].dis < t[t[x].rson].dis ) swap( t[x].lson, t[x].rson );t[x].dis = t[t[x].rson].dis + 1;return x;
}void dfs( int u, int fa ) {dep[u] = dep[fa] + 1;for( auto v : G[u] ) {dfs( v, u );root[u] = merge( root[u], root[v] );//将所有从子树的管辖城市中存活到u城市的骑士进行合并 }while( root[u] and t[root[u]].val < h[u] ) {//从最小杀伤力骑士开始 将所有在u城市死亡的骑士剔除 并记录最后答案 pushdown( root[u] );ans1[u] ++;ans2[root[u]] = dep[c[root[u]]] - dep[u];//骑士能攻占的数量巧妙利用初末深度差 最开始的城市深度-u的深度 root[u] = merge( t[root[u]].lson, t[root[u]].rson ); }if( a[u] ) modify( root[u], v[u], 0 );else modify( root[u], 1, v[u] );
}signed main() {scanf( "%lld %lld", &n, &m );for( int i = 1;i <= n;i ++ ) scanf( "%lld", &h[i] );for( int i = 2, f;i <= n;i ++ ) {scanf( "%lld %lld %lld", &f, &a[i], &v[i] );G[f].push_back( i );}t[0].dis = -1;//在每一座城市都建立一个左偏树 for( int i = 1;i <= m;i ++ ) {scanf( "%lld %lld", &t[i].val, &c[i] );root[c[i]] = merge( root[c[i]], i );//将在同一座城市的骑士在左偏树上体现合并 //root[i]:在城市i的左偏树的最小杀伤力骑士的编号 }dfs( 1, 0 );//搜城 从下往上爬 while( root[1] ) {/*最后在总城市根1的骑士答案还未计算 暴力弹出所有存活的骑士 攻占的数量就是初始城市到1号超级城市一路经过的城市也就是深度*/ ans2[root[1]] = dep[c[root[1]]];root[1] = merge( t[root[1]].lson, t[root[1]].rson );}for( int i = 1;i <= n;i ++ ) printf( "%lld\n", ans1[i] );for( int i = 1;i <= m;i ++ ) printf( "%lld\n", ans2[i] );return 0;
}

[Baltic2004]sequence

BZOJ 1367

给定$n$，以及长度为$n$的整数序列$a_1,...,a_n$，你需要构造一个严格上升的长度为$n$整数序列$t_1,...,t_n$，定义$R=|t_1-a_1|+...+|t_i-a_i|+...+|t_n-a_n|$，求最小的$R$

$n\le 10^6$

---

假设是构造不下降序列

考虑两种特殊的序列

• $a_1\le a_2\le ...\le a_n$，直接让$t_i=a_i$，最后答案就是$0$
• $a_1\ge a_2\ge ...\ge a_n$，直接让$t_1=a_{mid}$（序列的中位数）

现在考虑一般形式的$a$

将$a$序列划分成这两种特殊序列的若干段

考虑$1...i$的答案为$w_1,...w_i$，现在考虑$i+1$，先让$w_{i+1}=a_{i+1}$

然后就要根据第二种特殊序列，进行合并，如果$w_i\ge w_{i+1}$，就合并后$w_i=w_{i+1}=$中位数，直到$w_j<w_{i+1}$

这个中位数是参与合并的$w$中的中位数，不是整体的中位数

用左偏树维护一个$siz$大小即可

#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 1000005
struct node {int lson, rson, val, siz, dis;
}t[maxn];
int n, cnt;
int root[maxn], L[maxn], R[maxn], a[maxn];int merge( int x, int y ) {if( ! x or ! y ) return x + y;if( t[x].val < t[y].val ) swap( x, y );t[x].rson = merge( t[x].rson, y );t[x].siz = t[t[x].lson].siz + t[t[x].rson].siz + 1;if( t[t[x].lson].dis < t[t[x].rson].dis )swap( t[x].lson, t[x].rson );t[x].dis = t[t[x].rson].dis + 1;return x;
}long long Fabs( long long x ) {return x < 0 ? -x : x;
}int NewNode( int x ) {t[++ cnt].val = x;t[cnt].siz = 1;t[cnt].lson = t[cnt].rson = t[cnt].dis = 0;return cnt;
}int main() {scanf( "%d", &n );for( int i = 1;i <= n;i ++ )scanf( "%d", &a[i] ), a[i] -= i;t[0].dis = -1;int ip = 0;for( int i = 1;i <= n;i ++ ) {++ ip;L[ip] = R[ip] = i;root[ip] = NewNode( a[i] );while( ip > 1 and t[root[ip - 1]].val > t[root[ip]].val ) {root[ip - 1] = merge( root[ip - 1], root[ip] );R[ip - 1] = R[ip];ip --;while( t[root[ip]].siz * 2 > R[ip] - L[ip] + 2 )root[ip] = merge( t[root[ip]].lson, t[root[ip]].rson );}}long long ans = 0;while( ip ) {int val = t[root[ip]].val;for( int i = L[ip];i <= R[ip];i ++ )ans += Fabs( 1ll * val - a[i] );ip --;}printf( "%lld\n", ans );return 0;
}