Title Description
Linux users and OSX users must be familiar with package manager. Through the package manager, you can install a package through a line of commands, and then the package manager will help you download the package from the software source, and automatically solve all the dependencies (that is, download and install other packages that the installation of this package depends on), and complete all the configurations. Apt get for Debian/Ubuntu, yum for Fedora/CentOS, and homebrew for OSX are excellent package managers.
You decide to design your own package manager. Inevitably, you have to solve the problem of dependencies between packages. If package a relies on package B, package B must be installed before package a can be installed. At the same time, if you want to uninstall package B, you must uninstall package a. Now you have all the dependencies between packages. Moreover, due to your previous work, except for package 0, all packages in your manager will depend on one and only one package, while package 0 does not depend on any one package. There is no ring (if there are m(m ≥ 2) packages A1,A2,A3,..., Am, where a1 depends on A2, A2 depends on A3, A3 depends on A4,... A[m-1] depends on Am, and Am depends on A1, which is called the dependency of these m software packages to form a ring). Of course, there will not be a software package dependent on itself.
Now you write a dependency solution for your package manager. According to the feedback, users want to quickly know how many packages the operation will actually change when installing and uninstalling a package (that is, how many packages are not installed during the installation operation, or how many installed packages are uninstalled during the uninstallation operation). Your task is to realize this part. Note that installing an installed package or uninstalling an uninstalled package will not change the installation status of any package, that is, in this case, the number of packages that change the installation status is 0.
Input format
Read in the data from the file manager.in.
Line 1 of the input file contains an integer n representing the total number of packages. Packages are numbered from 0.
The next line contains n − 1 integers, separated by a single space between adjacent integers, representing the number of packages that package 1, 2, 3,..., n − 2,n − 1 depends on.
The next line contains an integer q, which represents the total number of queries. Then line q, one query per line. There are two types of inquiry:
install x: indicates to install package x
uninstall x: indicates to uninstall package x
You need to maintain the installation status of each package. At the beginning, all packages are not installed.
For each operation, you need to output how many packages the operation will change the installation status, and then apply the operation (that is, change the installation status you maintain).
Output format
Output to the file manager.out.
The output file includes line q.
Output an integer in line i of the output file, which is the number of packages changing the installation status in step i.
Example of input and output
Enter "copy 1"
7 0 0 0 1 1 5 5 install 5 install 6 uninstall 1 install 4 uninstall 0
Output 1 copy
3 1 3 2 3
Enter 2 copy
10 0 1 2 1 3 0 0 3 2 10 install 0 install 3 uninstall 2 install 7 install 5 install 9 uninstall 9 install 4 install 1 install 9
Output 2 copy
1 3 2 1 3 1 1 1 0 1
Description / tips
[example 1]
At first, all the packages were not installed.
To install package 5, you need to install three packages: 0, 1 and 5.
Then install package 6. You only need to install package 6. Four packages 0,1,5,6 are installed.
To uninstall package 1, you need to uninstall package 1, 5 and 6. At this time, only package 0 is still installed.
Then install package 4. You need to install package 1 and package 4. 0,1,4 are now installed. Finally, uninstalling package 0 uninstalls all packages. `
[data range]
[time limit 1s, memory 512M]
Understanding of tree building after tree cutting
The basis of tree chain segmentation is not mentioned. Tree building and query is to take a heavy chain or light chain as an interval to find distance (the heavy chain and light chain are continuous after tree segmentation), so as to speed up query speed.
thinking
Unload: calculate the downloaded points in the subtree with this point as the root node, that is, query quary2 (ID [x], ID [x] + size [x] - 1, 1)
[ID [x], ID [x] + size [x] - 1] is the interval of X subtree.
Download: the number of downloaded points on the path from the root to the point is calculated, and then the number is subtracted by the depth of the point, that is, ans_i = dep [x] - sum1
Code
Digestion and understanding, tree dissection...
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <map>
#define N 100005
using namespace std ;
int n , m , ans ;
int dep[N] , fa[N] , son[N] , Size[N] ;
int top[N] , id[N] , be[N] , cnt ;//DFS sequence with id as point x, be as the corresponding point of DFS sequence
vector <int> G[N] ;
struct node {
int l , r , sum ;
int lazy ;
} Tree[4*N] ;
void pushup( int x ) {//To update
int lson = 2*x , rson = 2*x+1 ;
Tree[x].sum = Tree[lson].sum + Tree[rson].sum ;
}
void pushdown( int x ) {//Drop lazy flag
if( Tree[x].lazy == 1 ) {
Tree[x].lazy = 0 ;
Tree[x*2].sum = Tree[x*2].r-Tree[x*2].l+1 ;
Tree[x*2+1].sum = Tree[x*2+1].r-Tree[x*2+1].l+1 ;//Update left and right sons
Tree[x*2].lazy = Tree[x*2+1].lazy = 1 ;
return ;
}
if( Tree[x].lazy == 2 ) {
Tree[x].lazy = 0 ;
Tree[x*2].sum = Tree[x*2+1].sum = 0 ;//Update left and right sons
Tree[x*2].lazy = Tree[x*2+1].lazy = 2 ;
}
}
void build( int l, int r , int x ) {//Line segment tree
if( l == r ) {
Tree[x].lazy = 0 ;
Tree[x].l = Tree[x].r = l ;
Tree[x].sum = 0 ;
return ;
}
Tree[x].sum = 0 , Tree[x].lazy = 0 ;
Tree[x].l = l , Tree[x].r = r ;
int mid = (l+r)/2 ;
build(l,mid,x*2);
build(mid+1,r,x*2+1);
pushup(x) ;
}
int quary1( int l , int r , int x ) {//download
if( l > r )
swap(l,r) ;
if( l <= Tree[x].l && r >= Tree[x].r ) {
int sum = Tree[x].sum ;
Tree[x].sum = Tree[x].r-Tree[x].l+1 ;//Download assignment
Tree[x].lazy = 1 ;//Lazy mark
return sum ;
}
int mid = (Tree[x].l+Tree[x].r)/2 ;
pushdown(x) ;//Drop lazy flag
int sum = 0 ;
if( l <= mid )
sum += quary1(l,r,x*2) ;
if( r >= mid+1 )
sum += quary1(l,r,2*x+1) ;
pushup(x) ;//To update
return sum ;
}
int quary2( int l , int r , int x ) {//uninstall
if( l > r )
swap(l,r) ;
if( l <= Tree[x].l && r >= Tree[x].r ) {
int sum = Tree[x].sum ;
Tree[x].sum = 0 ;//Unload cleared
Tree[x].lazy = 2 ;//Lazy mark
return sum ;
}
int mid = (Tree[x].l+Tree[x].r)/2 ;
pushdown(x);//Drop lazy flag
int sum = 0 ;
if( l <= mid )
sum += quary2(l,r,x*2) ;
if( r >= mid+1 )
sum += quary2(l,r,2*x+1) ;
pushup(x) ;//To update
return sum ;
}
void DFS1( int x , int f , int deep ) {
fa[x] = f ;
dep[x] = deep ;
Size[x] = 1 ;
for( int i = 0 ; i < G[x].size() ; ++ i ) {
int s = G[x][i] ;
if( s == f )
continue;
DFS1( s,x,deep+1 );
Size[x] += Size[s] ;
if( Size[s] > Size[son[x]] || !son[x] )
son[x] = s ;
}
}
void DFS2( int x , int T ) {
top[x] = T ;
cnt ++ ;
id[x] = cnt ;
be[cnt] = x ;
if( !son[x] )
return ;
DFS2( son[x] , T );
for( int i = 0 ; i < G[x].size() ; ++ i ) {
int s = G[x][i] ;
if( s == son[x] || s == fa[x] )
continue ;
DFS2(s,s);
}
}
int Get_sum( int x , int y ) {
int sum = 0 ;
while( top[x] != top[y] ) {
if( dep[x] < dep[y] )
swap(x,y) ;
sum += quary1( id[x],id[top[x]],1 );
x = fa[top[x]] ;
}
sum += quary1( id[x],id[y],1 );
return sum ;
}
int main() {
scanf("%d", &n );
for( int i = 1 ; i < n ; ++ i ) {
int x ;
scanf("%d", &x );
G[i].push_back(x) ;
G[x].push_back(i) ;
}
cnt = 0 ;
DFS1(0,-1,1);
DFS2(0,0) ;
build(1,n,1);
scanf("%d", &m );
while( m -- ) {
string Fuck ;
cin >> Fuck ;
int x ;
scanf("%d", &x );
if( Fuck[0] == 'i' ) {
ans = Get_sum(x,0);
printf("%d\n", dep[x]-ans );
}
else {
ans = quary2( id[x] , id[x]+Size[x]-1 , 1 );
printf("%d\n", ans ) ;
}
}
}