題目大意

現有一顆有根樹，葉子節點可被染成黑色（最開始都是白色），也可以被染回白色，現在問給出每次染色資訊後（即帶修改），最少需要切斷幾條邊保證黑色葉子不在樹上，且在此條件下最少有多少白色葉子不在樹上。

解題思路

大體演算法：DFS序+倍增
很容易發現，被切斷的邊數最多隻需要與根節點相連的邊數，因為根節點連出去的每顆子樹最多隻需要一條邊就可以切斷，所以每顆子樹都是獨立的。
這樣問題就轉化為了找出每課子樹中被染黑的葉子節點的最近公共祖先，多個點的LCA我發現可以用DFS序+倍增在O(logN)找出（沒百度到相關解法，自己YY加上hzh提示想出來的）

具體實現：
從根出發dfs，dfs的時候需要維護四個東西：1.時間戳，dfn[]記錄訪問時間，low[]記錄子樹中最晚訪問的點的dfn[]；2.f[][]，倍增方法記錄祖先；3.siz[]統計子樹中葉子節點的個數；4.所屬子樹編號
然後對每顆子樹建立一個大根堆和小根堆，維護一顆子樹中黑色葉子dfn的最大值maxx和最小值minn，因為還要帶刪除，如果用用優先佇列還需要一個輔助陣列。然後從一個黑色葉子節點出發，用倍增找出最近公共祖先，條件是（dfn[fa] <= minn && low[fa] >= maxx），找到LCA後，再利用利用siz陣列，很容易得出答案

~~~程式碼比較醜

#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const int maxn = 100010;
const int lg = 20;

int f[maxn][lg];
int n,q;
int pre_ans[maxn];
int pre_cnt[maxn];
int siz[maxn],cnt;
int x,index = 1;
char c;
int dfn[maxn],low[maxn],p[maxn];
bool co[maxn];
struct edge
{
    int v,next;
}e[maxn << 1];
int h[maxn],num;
int pos_cnt = 0;
struct node_max
{
    int pos,x;
    node_max(int _pos,int _x)
    {
        pos = _pos;
        x = _x;
    }
    friend bool operator< (node_max a,node_max b)
    {
        return a.x < b.x;
    }
};
struct node_min
{
    int pos,x;
    node_min(int _pos,int _x)
    {
        pos = _pos;
        x = _x;
    }
    friend bool operator< (node_min a,node_min b)
    {
        return a.x > b.x;
    }
};

priority_queue<node_max>qmax[maxn];
priority_queue<node_min>qmin[maxn];

void build_edge(int u,int v)
{
    num++;
    e[num].v = v;
    e[num].next = h[u];
    h[u] = num;
}

void dfs(int x,int pos,int fa)
{
    dfn[x] = ++index;
    p[x] = pos;
    f[x][0] = fa;
    for(int i = 1; i < lg; i++)
        f[x][i] = f[f[x][i-1]][i-1];
    for(int i = h[x]; i; i = e[i].next)
    {
        dfs(e[i].v,pos,x);
        siz[x] += siz[e[i].v];
    }
    low[x] = index;
    if(low[x] == dfn[x])
        siz[x] = 1;
}

bool inqueue_max[maxn];
bool inqueue_min[maxn];

int getRoot(int x)
{
    if(pre_cnt[x] == 0)
        return 0;
    while(!qmax[x].empty())
    {
        if(!co[qmax[x].top().x])
            inqueue_max[qmax[x].top().x] = false,qmax[x].pop();
        else
            break;
    }
    while(!qmin[x].empty())
    {
        if(!co[qmin[x].top().x])
            inqueue_min[qmin[x].top().x] = false,qmin[x].pop();
        else
            break;
    }
    int maxx,minn,u;
    maxx = qmax[x].top().x;
    minn = qmin[x].top().x;
    u = qmax[x].top().pos;
    if(pre_cnt[x] == 1)
        return u;
    for(int i = lg - 1; i >= 0; i--)
        while(dfn[f[u][i]] > minn || low[f[u][i]] < maxx)
            u = f[u][i];
    return f[u][0];
}

int main()
{
    freopen("gangsters.in","r",stdin);
    freopen("gangsters.out","w",stdout);
    scanf("%d%d",&n,&q);
    for(int i = 2; i <= n; i++)
    {
        scanf("%d",&x);
        build_edge(x,i);
    }
    dfn[1] = 1, dfn[0] = 0;
    low[1] = n, low[0] = 9999999;
    for(int i = h[1]; i; i = e[i].next)
    {
        pos_cnt++;
        dfs(e[i].v,pos_cnt,1);
        siz[1] += siz[e[i].v];
    }
    int ans_cnt = 0;
    int ans_edge = 0;
    int now_ans;
    int root;
    while(q--)
    {
        scanf(" %c%d",&c,&x);
        if(c == '+')
        {
            pre_cnt[p[x]]++;
            if(pre_cnt[p[x]] == 1)
                ans_edge++;
            co[dfn[x]] = true;
            if(!inqueue_max[dfn[x]])
                qmax[p[x]].push(node_max(x,dfn[x]));
            else
                inqueue_max[dfn[x]] = false;
            if(!inqueue_min[dfn[x]])
                qmin[p[x]].push(node_min(x,dfn[x]));
            else
                inqueue_min[dfn[x]] = false;
        }
        else
        {
            co[dfn[x]] = false;
            pre_cnt[p[x]]--;
            if(pre_cnt[p[x]] == 0)
                ans_edge--;
            inqueue_max[dfn[x]] = true;
            inqueue_min[dfn[x]] = true;

        }
        root = getRoot(p[x]);
        now_ans = siz[root] - pre_cnt[p[x]];
        ans_cnt += now_ans - pre_ans[p[x]];
        pre_ans[p[x]] = now_ans;
        printf("%d %d\n",ans_edge,ans_cnt);
    }
    return 0;
}