平衡树
#include <cstdio>
using namespace std;
int root, tot;
struct tree
{
int v, cnt, size, son[2], fa;
void clr() {
v = cnt = size = son[0] = son[1] = fa = 0; }
} tr[100010];
bool ident(int x) {
return tr[tr[x].fa].son[1] == x; }
void connect(int fa, int x, int how)
{
tr[fa].son[how] = x;
tr[x].fa = fa;
}
int update(int x) {
return tr[x].size = tr[x].cnt + tr[tr[x].son[0]].size + tr[tr[x].son[1]].size; }
void rotate(int x)
{
int y = tr[x].fa;
int z = tr[y].fa;
int yson = ident(x);
connect(y, tr[x].son[yson ^ 1], yson);
connect(x, y, yson ^ 1);
tr[x].fa = z;
if (z)
tr[z].son[tr[z].son[1] == y] = x;
update(y);
update(x);
}
void splay(int x)
{
for (int fa; fa = tr[x].fa; rotate(x))
if (tr[fa].fa)
rotate(ident(fa) == ident(x) ? fa : x);
root = x;
}
void insert(int x)
{
if (!root)
{
tr[++tot].fa = 0;
tr[tot].cnt = 1;
tr[tot].v = x;
tr[tot].size = 1;
root = tot;
return;
}
int now = root, fa = 0;
while (1)
{
if (tr[now].v == x)
{
tr[now].cnt++;
tr[now].size++;
splay(now);
return;
}
fa = now;
now = tr[now].son[tr[now].v < x];
if (!now)
{
connect(fa, ++tot, tr[fa].v < x);
tr[tot].cnt = 1;
tr[tot].size = 1;
tr[tot].v = x;
splay(tot);
return;
}
}
}
int findx(int x)
{
int now = root, size = 0;
while (1)
{
if (!now)
return 0;
else if (tr[now].v <= x)
{
size += tr[tr[now].son[0]].size;
if (tr[now].v == x)
{
splay(now);
return size + 1;
}
size += tr[now].cnt;
now = tr[now].son[1];
}
else if (tr[now].v > x)
now = tr[now].son[0];
}
}
int find(int num)
{
int now = root;
while (1)
{
if (num > tr[tr[now].son[0]].size)
{
num -= tr[tr[now].son[0]].size;
if (num <= tr[now].cnt)
{
splay(now);
return tr[now].v;
}
num -= tr[now].cnt;
now = tr[now].son[1];
}
else
now = tr[now].son[0];
}
}
int qq()
{
int now = tr[root].son[0];
while (tr[now].son[1])
now = tr[now].son[1];
return now;
}
int hj()
{
int now = tr[root].son[1];
while (tr[now].son[0])
now = tr[now].son[0];
return now;
}
void del(int x)
{
if (!findx(x))
return;
int now = root, son;
if (tr[now].cnt > 1)
{
tr[now].cnt--;
tr[now].size--;
return;
}
if (!tr[now].son[1])
{
root = tr[now].son[0];
tr[root].fa = 0;
tr[now].clr();
return;
}
if (!tr[now].son[0])
{
root = tr[now].son[1];
tr[root].fa = 0;
tr[now].clr();
return;
}
splay(qq());
connect(root, tr[now].son[1], 1);
tr[now].clr();
update(root);
}
int main()
{
int n;
scanf("%d", &n);
while (n--)
{
int opt, x;
scanf("%d%d", &opt, &x);
if (opt == 1)
insert(x); //插入一个元素
if (opt == 2)
del(x); //删除一个元素
if (opt == 3)
printf("%d\n", findx(x)); //查询x的排名
if (opt == 4)
printf("%d\n", find(x)); //查询排名为x的数
if (opt == 5)
{
insert(x), printf("%d\n", tr[qq()].v), del(x);
} //求小于x且最大的数
if (opt == 6)
{
insert(x), printf("%d\n", tr[hj()].v), del(x);
} //求大于x且最小的数
}
}
可持久化线段树
void update(ll l, ll r, ll &now, ll p, ll c)
{
if (!p)
return;
if (!now)
now = ++cnt;
sum[now] += c;
if (l == r)
return;
ll m = (l + r) >> 1;
if (p <= m)
update(lson, p, c);
else
update(rson, p, c);
}
ll query(ll l, ll r, ll now, ll a, ll b)//查询权值在[a,b]范围内个数
{
if (!now)
return 0;
if (l >= a && r <= b)
return sum[now];
ll m = l + r >> 1, ans = 0;
if (a <= m)
ans = query(lson, a, b);
if (b > m)
ans += query(rson, a, b);
return ans;
}
主席树求区间第k大
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 60006
int a[N], b[N], R[N], T[N], n, tot;
int Ro[N], Lo[N], rn;
struct Q
{
char o;
int i, j, k;
}q[N/6];
struct Tr
{
int ls, rs, c;
}tr[N*40];
int build(int l, int r)
{
int mid = l+r>>1, root = tot++;
tr[root].c = 0;
if (l < r)
{
tr[root].ls = build(l, mid);
tr[root].rs = build(mid+1, r);
}
return root;
}
void init(int r)
{
tot = 0;
memset(R, 0, sizeof(R));
T[0] = build(1, r);
}
int lb(int k) {
return k&(-k);}
int update(int l, int r, int val, int root, int ad)
{
int nr = tot++, mid = l+r>>1;
tr[nr].c = tr[root].c+ad;
if (l == r) return nr;
if (val <= mid)
{
tr[nr].ls = update(l, mid, val, tr[root].ls, ad);
tr[nr].rs = tr[root].rs;
}
else
{
tr[nr].rs = update(mid+1, r, val, tr[root].rs, ad);
tr[nr].ls = tr[root].ls;
}
return nr;
}
void add(int i, int k, int r, int ad)
{
int v = lower_bound(b+1, b+r+1, k)-b;
while (i <= rn)
{
R[i] = update(1, r, v, R[i], ad);
i += lb(i);
}
}
void go(int root[], int d)
{
int i;
for (i = 1;i <= root[0];i++)
root[i] = d?tr[root[i]].rs:tr[root[i]].ls;
}
int query(int l, int r, int k, int Rroot, int Lroot)
{
if (l == r) return l;
int i, Rls = 0, Lls = 0, mid = l+r>>1;
int sum = tr[tr[Rroot].ls].c-tr[tr[Lroot].ls].c;
for (i = 1;i <= Ro[0];i++) Rls += tr[tr[Ro[i]].ls].c;
for (i = 1;i <= Lo[0];i++) Lls += tr[tr[Lo[i]].ls].c;
if (k <= Rls-Lls+sum)
{
go(Ro, 0), go(Lo, 0);
return query(l, mid, k, tr[Rroot].ls, tr[Lroot].ls);
}
else
{
go(Ro, 1), go(Lo, 1);
return query(mid+1, r, k+Lls-Rls-sum, tr[Rroot].rs, tr[Lroot].rs);
}
}
void cal(int i, int j, int k, int r)
{
Ro[0] = Lo[0] = 0;
int ti = j;
while (ti > 0)
{
Ro[++Ro[0]] = R[ti];
ti -= lb(ti);
}
ti = i;
while (ti > 0)
{
Lo[++Lo[0]] = R[ti];
ti -= lb(ti);
}
printf("%d\n", b[query(1, r, k, T[j], T[i])]);
}
int main()
{
int ca, m, i, j, k;
scanf("%d", &ca);
while (ca--)
{
scanf("%d%d", &n, &m);
rn = n;
for (i = 1;i <= n;i++)
{
scanf("%d", &a[i]);
b[i] = a[i];
}
for (i = 0;i < m;i++)
{
scanf(" %c", &q[i].o);
if (q[i].o == 'Q') scanf("%d%d%d", &q[i].i, &q[i].j, &q[i].k);
else scanf("%d%d", &q[i].i, &q[i].j), b[++n] = q[i].j;
}
sort(b+1, b+1+n);
int r = unique(b+1, b+1+n)-b-1;
init(r);
for (i = 1;i <= rn;i++) T[i] = update(1, r, lower_bound(b+1, b+1+r, a[i])-b, T[i-1], 1);
for (i = 0;i < m;i++)
{
if (q[i].o == 'Q') cal(q[i].i-1, q[i].j, q[i].k, r);
else
{
add(q[i].i, a[q[i].i], r, -1), add(q[i].i, q[i].j, r, 1);
a[q[i].i] = q[i].j;
}
}
}
}