P3038 区间修改，单调查询 ， 边塞点-重链剖分

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)

template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 200005;
int n , m;
vector <int> edge[N];

int value[N], rt; //节点值
int fa[N] , deep[N] , son[N] , size[N];
//   父亲        深度         重儿子       子树大小
int dfn[N] ,top[N], id[N], tot = 0;
//   dfs序编号    重链顶端  dfs序对应节点
void dfs1(int u)
{
    size[u] = 1;
    for(auto v : edge[u])
    {
        if(v != fa[u])
        {
            fa[v] = u;
            deep[v] = deep[u] + 1;
            dfs1(v);
            size[u] += size[v];
            if(size[v] > size[son[u]])
                son[u] = v;
        }
    }
}
void dfs2(int u ,int t)
{
    top[u] = t;
    dfn[u] = ++tot;
    id[tot] = u;
    if(son[u]) dfs2(son[u],t);
    for(auto v : edge[u])
    {
        if(v != son[u] && v != fa[u])
            dfs2(v,v);
    }
}
struct tree_node
{
    int l , r;
    ll sum ,lz;
}tree[N << 2];
void pushdown(int i)
{
    if(tree[i].lz != 0)
    {
        tree[i*2].lz += tree[i].lz;
        tree[i*2+1].lz += tree[i].lz;
        int mid = (tree[i].l+tree[i].r)/2;
        tree[i*2].sum += tree[i].lz*(mid - tree[i*2].l + 1);
        tree[i*2+1].sum += tree[i].lz*(tree[i*2+1].r - mid);
        tree[i].lz = 0;
    }
    return ;
}
void build(int i , int l , int r)
{
    tree[i].l = l, tree[i].r = r, tree[i].lz = 0, tree[i].sum = 0;
    if(l == r)
    {
        tree[i].sum = value[id[l]];
        return ;
    }
    int mid = (l + r) >> 1;
    build(i*2,l,mid);
    build(i*2+1,mid+1,r);
    tree[i].sum = tree[i*2].sum + tree[i*2+1].sum;
}
void update(int i , int l , int r , int k)
{
    if(tree[i].l >= l && tree[i].r <= r)
    {
        tree[i].sum += (tree[i].r-tree[i].l+1)*k;
        tree[i].lz += k;
        return ;
    }
    pushdown(i);
    if(l <= tree[i*2].r)
        update(i*2,l,r,k);
    if(tree[i*2+1].l <= r)
        update(i*2+1,l,r,k);
    tree[i].sum = tree[i*2].sum + tree[i*2+1].sum;
    return ;
}
int search(int i , int l , int r)
{
    if(tree[i].l >= l && tree[i].r <= r) {
        return tree[i].sum;
    }
    if(l > tree[i].r || r < tree[i].l)
        return 0;
    pushdown(i);
    int ans = 0;
    if(tree[i*2].r >= l)
        ans += search(i * 2, l, r);
    if(tree[i*2+1].l <= r)
        ans += search(i * 2 + 1, l, r);
    return ans;
}
void TreeAdd(int x, int y, int val)
{
    while(top[x] != top[y])
    {
        if(deep[top[x]] < deep[top[y]])
            swap(x,y);
        update(1,dfn[top[x]], dfn[x], val);
        x = fa[top[x]];
    }
    if(deep[x] > deep[y]) swap(x,y);
    update(1,dfn[x],dfn[y],val);
    update(1,dfn[x],dfn[x],-1);
}
int main()
{
    read(n,m);
    for (int i = 1; i <= n - 1 ; i ++)
    {
        int u , v;
        read(u , v);
        edge[u].pb(v);
        edge[v].pb(u);
    }
    rt = 1;
    dfs1(rt);
    /*
     *     边塞点，网深度大的塞
    for (int u = 1; u <= n ; u ++)
    {
        for (auto v : edge[u])
        {
            if(deep[u] > deep[v] && value[u] == -1)
                value[u] = edge[u].w;
            if(deep[v] < deep[u] && value[v] == -1)
                value[v] = edge[u].w;
        }
    */
    dfs2(rt,rt);
    build(1,1,n);
    for (int i = 1; i <= m ; i ++)
    {
        char op;
        int u , v;
        cin >> op;
        read(u,v);
        if(op == 'P') {
            TreeAdd(u, v, 1);
        }
        else
        {
            if(deep[u] < deep[v])
                swap(u,v);
            write(search(1,dfn[u], dfn[u])), LF;
        }
    }

}
/*
5
2 3 6 7 8
 */