BZOJ 4756 Promotion Counting（线段树合并 || dfs）

题意：给你一棵n个节点的树，根为1，问你每个节点，它的子树中有几个节点比它大。

思路：

有一个简单的方法是可以遍历一下这棵树，树状数组维护，对于每个点的答案为 子树节点个数-（遍历它后比它小的数的个数-遍历它前比它小的数的个数）。遍历完它的子树节点后把它插入树状数组。

还有一个方法是对于每个节点建立一颗权值线段树，然后自底向上合并，每次合并后就可以直接查找比它大的数的个数，因为此时的树中只有它子树的节点。

线段树合并代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 1e5+5;
const int maxnode = 2e6+5;
int tree[maxnode], lch[maxnode], rch[maxnode];
int a[maxn], b[maxn], head[maxn], root[maxn], ans[maxn];
int n, k, sz, seg;
struct node
{
int v, next;
}edge[maxn];

void init()
{
k = 0, sz = 1, seg = 0;
memset(head, -1, sizeof(head));
memset(tree, 0, sizeof(tree));
memset(root, 0, sizeof(root));
memset(rch, 0, sizeof(rch));
memset(lch, 0, sizeof(lch));
}

void addEdge(int u, int v)
{
edge[k].v = v;
edge[k].next = head[u];
head[u] = k++;
}

void pushup(int rt)
{
tree[rt] = tree[lch[rt]]+tree[rch[rt]];
}

void build(int &rt, int l, int r, int pos)
{
rt = ++seg;
if(l == r)
{
tree[rt] = 1;
return ;
}
int mid = (l+r)/2;
if(pos <= mid) build(lch[rt], l, mid, pos);
else build(rch[rt], mid+1, r, pos);
pushup(rt);
}

int query(int rt, int l, int r, int i, int j)
{
if(i <= l && j >= r) return tree[rt];
int mid = (l+r)/2;
int res = 0;
if(i <= mid) res += query(lch[rt], l, mid, i, j);
if(j > mid) res += query(rch[rt], mid+1, r, i, j);
return res;
}

int merge(int x, int y)
{
if(!x) return y;
if(!y) return x;
lch[x] = merge(lch[x], lch[y]);
rch[x] = merge(rch[x], rch[y]);
pushup(x);
return x;
}

void dfs(int u)
{
for(int i = head[u]; ~i; i = edge[i].next)
{
int v = edge[i].v;
dfs(v);
root[u] = merge(root[u], root[v]);
}
ans[u] = query(root[u], 1, n, a[u]+1, n);
}

int main(void)
{
while(cin >> n)
{
init();
for(int i = 1; i <= n; i++)
scanf("%d", &a[i]), b[i] = a[i];
sort(b+1, b+1+n);
int t = unique(b+1, b+1+n)-b-1;
for(int i = 1; i <= n; i++)
a[i] = lower_bound(b+1, b+1+t, a[i])-b;
for(int i = 2; i <= n; i++)
{
int x;
scanf("%d", &x);
addEdge(x, i);
}
for(int i = 1; i <= n; i++)
build(root[i], 1, n, a[i]);
dfs(1);
for(int i = 1; i <= n; i++)
printf("%d\n", ans[i]);
}
return 0;
}


dfs代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 1e5+5;
const int maxm = 5e5+5;
int ans[maxn], num[maxn], head[maxm], tree[maxn];
int n, k, a[maxn], b[maxn];
struct node
{
int v, next;
}edge[maxm];

void init()
{
k = 0;
memset(head, -1, sizeof(head));
memset(num, 0, sizeof(num));
memset(tree, 0, sizeof(tree));
}

void addEdge(int u, int v)
{
edge[k].v = v;
edge[k].next = head[u];
head[u] = k++;
}

int lowbit(int x)
{
return x&(-x);
}

void update(int pos, int val)
{
while(pos < maxn)
{
tree[pos] += val;
pos += lowbit(pos);
}
}

int query(int pos)
{
int res = 0;
while(pos)
{
res += tree[pos];
pos -= lowbit(pos);
}
return res;
}

void dfs(int u)
{
int pre = query(a[u]);
num[u] = 1;
for(int i = head[u]; ~i; i = edge[i].next)
{
int v = edge[i].v;
dfs(v);
num[u] += num[v];
}
int cur = query(a[u]);
ans[u] = num[u]-(cur-pre)-1;
update(a[u], 1);
}

int main(void)
{
while(cin >> n)
{
init();
for(int i = 1; i <= n; i++)
scanf("%d", &a[i]), b[i] = a[i];
sort(b+1, b+1+n);
int t = unique(b+1, b+1+n)-b-1;
for(int i = 1; i <= n; i++)
a[i] = lower_bound(b+1, b+1+t, a[i])-b;
for(int i = 2; i <= n; i++)
{
int x;
scanf("%d", &x);
addEdge(x, i);
}
dfs(1);
for(int i = 1; i <= n; i++)
printf("%d\n", ans[i]);
}
return 0;
}