bzoj3133

3133: [Baltic2013]ballmachine

Time Limit: 20 Sec   Memory Limit: 128 MB
Submit: 108   Solved: 41
[ Submit][ Status][ Discuss]

Description

有一个装球机器，构造可以看作是一棵树。有下面两种操作：

• 从根放入一个球，只要下方有空位，球会沿着树滚下。如果同时有多个点可以走，那么会选择编号最小的节点所在路径的方向。比如依次在树根4放2个球，第一个球会落到1，第二个会落到3：
• 

• 从某个位置拿走一个球，那么它上方的球会落下来。比如依次拿走5, 7, 8三个球：

Input

第一行：球的个数N，操作个数Q （N, Q <= 100 000）下面N行：第i个节点的父亲。如果是根，则为0 接下来Q行：op num

1. op == 1：在根放入num个球
2. op == 2：拿走在位置num的球

Output

保证输入合法

1. op == 1：输出最后一个球落到了哪里
2. op == 2：输出拿走那个球后有多少个球会掉下来

Sample Input

8 4
0
1
2
2
3
3
4
6
1 8
2 5
2 7
2 8

Sample Output

1
3
2
2

HINT

Source

abcdabcd987提供

题解：

考虑从空树一直放球直到放满为止，则掉落位置构成一个全序。

比如样例中的顺序是58637421，那么当位置6没有球时，球就不会掉到37421上。

所以用堆维护所有球可能掉到的位置就可以了。这些位置就是没有球的点构成的树的叶子节点。

取出一个球就是找从这个点到根最浅的有球的点，可以用树剖或倍增。（树剖又慢又长。）

（想知道怎么写能更短。。。）

#include <stdio.h>
#include <algorithm>
#include <queue>

using namespace std;

const int maxn = 120000;
int order[maxn];
struct so {
	int v , minn;
};
struct getnext {
	int v;
};
bool operator > ( so x1 , so x2 ) {
	return x1.minn > x2.minn;
}
bool operator > ( getnext x1 , getnext x2 ) {
	return order[x1.v] > order[x2.v];
}
struct heap {
	priority_queue < getnext , vector < getnext > , greater < getnext > > p , q;
	getnext top () {
		while ( q.size () != 0 && p.top ().v == q.top ().v ) p.pop (), q.pop ();
		return p.top ();
	}
	bool empty () {
		while ( q.size () != 0 && p.top ().v == q.top ().v ) p.pop (), q.pop ();
		if ( p.size () == 0 ) return true;
		return false;
	}
	void push ( int x ) {
		getnext tmp;
		tmp.v = x;
		p.push ( tmp );
	}
	void pop ( int x ) {
		getnext tmp;
		tmp.v = x;
		q.push ( tmp );
	}
} h;
struct tree {
	int v;
	tree *next;
} poolt[maxn*2] , *g[maxn];
int topt;
int n , q;
int fa[maxn] , dep[maxn] , sonnum[maxn] , mnum[maxn];
int f[maxn];
int go[18][maxn];
int root;
int index1;
void add ( int u , int v ) {
	tree *tmp = &poolt[++topt];
	tmp -> v = v; tmp -> next = g[u]; g[u] = tmp;
}
void dfs1 ( int i ) {
	mnum[i] = i;
	for ( tree *j = g[i] ; j ; j = j -> next ) if ( !mnum[j->v] ) {
		sonnum[i]++;
		dep[j->v] = dep[i] + 1;
		fa[j->v] = i;
		dfs1 ( j -> v );
		mnum[i] = min ( mnum[i] , mnum[j->v] );
	}
}
void getorder ( int i , int from ) {
	priority_queue < so , vector < so > , greater < so > > que;
	so tmp;
	for ( tree *j = g[i] ; j ; j = j -> next ) if ( j -> v != from ) {
		tmp.v = j -> v; tmp.minn = mnum[j->v];
		que.push ( tmp );
	}
	while ( que.size () != 0 ) {
		getorder ( que.top().v , i );
		que.pop ();
	}
	order[i] = ++index1;
}
void change ( int x ) {
	f[x] = 1 - f[x];
}
int find ( int i ) {
	for ( int j = 16 ; j >= 0 ; j-- ) if ( f[go[j][i]] == 1 ) i = go[j][i];
	return i;
}
void put () {
	getnext tmp = h.top ();
	h.pop ( tmp.v );
	change ( tmp.v );
	//printf ( "%d\n" , w[tmp.v] );
	sonnum[fa[tmp.v]]--;
	if ( sonnum[fa[tmp.v]] == 0 ) h.push ( fa[tmp.v] ); 
}
int take ( int i ) {
	int tmp = find ( i );
	//printf ( "%d\n" , tmp );
	change ( tmp );
	h.push ( tmp ); 
	if ( sonnum[fa[tmp]] == 0 ) h.pop ( fa[tmp] );
	sonnum[fa[tmp]]++; 
	return dep[i] - dep[tmp];
}
void work () {
	int i , j , v , op , num , ans;
	scanf ( "%d%d" , &n , &q );
	for ( i = 1 ; i <= n ; i++ ) {
		scanf ( "%d" , &v );
		if ( v != 0 ) add ( i , v ), add ( v , i );
		else root = i;
	}
	dep[root] = 1;
	dfs1 ( root );
	for ( i = 1 ; i <= n ; i++ ) go[0][i] = fa[i];
	for ( i = 1 ; i <= 16 ; i++ ) for ( j = 1 ; j <= n ; j++ ) go[i][j] = go[i-1][go[i-1][j]];
	//for ( i = 1 ; i <= n ; i++ ) printf ( "%d\n" , w[i] );
	getorder ( root , -1 );
	for ( i = 1 ; i <= n ; i++ ) if ( sonnum[i] == 0 ) h.push ( i ); 
	for ( i = 1 ; i <= q ; i++ ) {
		scanf ( "%d%d" , &op , &num );
		if ( op == 1 ) {
			for ( j = 1 ; j <= num ; j++ ) {
				ans = h.top ().v;
				//printf ( "%d %d %d\n" , h.top().v , h.top().minn , h.top().dep );
				put ();
			}
			printf ( "%d\n" , ans );
		}
		else {
			ans = take ( num );
			printf ( "%d\n" , ans );
		}
	}
}
int main () {
	//FILE *fpr = freopen ( "bzoj3133.in" , "r" , stdin );
	//FILE *fpw = freopen ( "bzoj3133.out" , "w" , stdout );
	work ();
	return 0;
}