[LNOI2014]LCA

～～～题面～～～

题解：

　　首先我们要转化一下，因为直接求不好求。首先考虑一个点对z的贡献，观察这么一个图：

　　显然点x对点z的贡献为2，因为LCA的深度为2。LCA可以看做点x和点z分别走向root的两条路径中第一个重合的点，因此，如果我们给x到root的路径上的点都赋1的点权，那么再从z往上走，

　　因为LCA是两条路径中第一个重合的点，因此我们会从LCA开始获取点权，那么走到root后得到的点权和刚好就是点x对点z的贡献！

　　因此我们直接做一个树链剖分，然后用线段树来维护区间加和区间查询即可。

　　然而直接对每个询问都这么做显然是会超时的，因此我们要考虑一些效率更高的做法。

　　因为每个询问都是一个区间的查询，而且符合区间减法，即对于同一点而言ans[1, r] - ans[1, l -1] = ans[l, r]。

　　这时思路就很明确了，我们可以从1开始枚举，依次进行区间加，然后每次加了之后就处理一遍相关的询问，跟tarjan求LCA的思想有一点点类似。

　　获取了ans[1, r] 和 ans[1, l - 1]后就可以很方便的求出ans[l, r]了。

　　

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 50100
#define ac 500100
#define mod 201314
#define getchar() *o++
char READ[5000100], *o = READ;
int n, m, cnt, rnt;
int Head[AC], Next[AC], date[AC], all;
int Size[AC], son[AC], father[AC], dep[AC], ans[AC], top[AC], id[AC], d[AC], last[AC];

struct node{
    int Head[AC], Next[AC*2], date[AC*2], id[AC*2], tot;//error!!!询问会存2次啊，左端点和右端点啊，，，数组开两倍啊!!!
    void add(int f, int w, int S)//存询问
    {
        date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, id[tot] = S;
    }
}E;

struct _question{
    int l, r, x;
}q[AC];

inline void add(int f, int w)
{
    date[++all] = w, Next[all] = Head[f], Head[f] = all;
}

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c -'0', c = getchar();
    return x;
}

void pre()
{
    int a;
    n = read(), m = read();
    for(R i = 2; i <= n; i++)
    {
        a = read() + 1;//编号从移到1开始算
        add(a, i);
        father[i] = a;
    }
    for(R i = 1; i <= m; i++)
    {
        q[i].l = read() + 1, q[i].r = read() + 1, q[i].x = read() + 1;
        if(q[i].l > q[i].r) swap(q[i].l, q[i].r);
        E.add(q[i].l - 1, q[i].x, i);//从前向后枚举点x差分，这样就会先遇到左端点，
        E.add(q[i].r, q[i].x, i);//所以遇到右端点查询的时候就直接减就可以了
    }
    dep[1] = 1;
}

void dfs1(int x)//get Size, son, dep
{
    int now, maxn = 0;
    Size[x] = 1;//先加上自己
    for(R i = Head[x]; i; i = Next[i])
    {
        now = date[i];
        if(now == father[x]) continue;
        dep[now] = dep[x] + 1;
        dfs1(now);
        Size[x] += Size[now];
        if(Size[now] > Size[maxn]) maxn = now;
    }
    son[x] = maxn;
}

void dfs2(int x, int topx)//get id, top
{
    int now;
    id[x] = ++cnt, top[x] = topx;
    if(!son[x]) return ;
    dfs2(son[x], topx);//重链需要继承
    last[x] = son[x];
    for(R i = Head[x]; i; i = Next[i])
    {
        now = date[i];
        if(now == father[x] || now == son[x]) continue;//如果是父亲or重儿子就跳过
        dfs2(now, now);//新开链
    }
}

int tree[ac], lazy[ac], l[ac], r[ac];

void build(int x, int ll, int rr)
{
    if(ll == rr)
    {
        l[x] = r[x] = ll;
        return ;
    }
    l[x] = ll, r[x] = rr;
    int mid = (ll + rr) >> 1;
    build(x * 2, ll, mid);
    build(x * 2 + 1, mid + 1, rr);

}

inline void pushdown(int x)
{
    if(lazy[x])
    {
        int ll = x * 2, rr = ll + 1;
        lazy[ll] += lazy[x], lazy[rr] += lazy[x];
        tree[ll] += lazy[x] * (r[ll] - l[ll] + 1) , tree[rr] += lazy[x] * (r[rr] - l[rr] + 1);
        lazy[x] = 0;
    }
}

inline void update(int x)
{
    tree[x] = tree[x * 2] + tree[x * 2 + 1];
}

void add(int x, int ll, int rr)//区间加
{
    pushdown(x);
    if(l[x] == ll && r[x] == rr)
    {
        tree[x] += (rr - ll + 1);
        lazy[x] += 1;
        return ;
    }
    int mid = (l[x] + r[x]) >> 1;
    if(rr <= mid) add(x * 2, ll, rr);
    else if(ll > mid) add(x * 2 + 1, ll, rr);
    else 
    {
        add(x * 2, ll, mid);
        add(x * 2 + 1, mid + 1, rr);
    }
    update(x);
}

void search(int x, int ll, int rr)//查询
{
    pushdown(x);
    if(l[x] == ll && r[x] == rr)
    {
        rnt += tree[x];
        return ;
    }
    int mid = (l[x] + r[x]) >> 1;
    if(rr <= mid) search(x * 2, ll, rr);
    else if(ll > mid) search(x * 2 + 1, ll, rr);
    else 
    {
        search(x * 2, ll, mid);
        search(x * 2 + 1, mid + 1, rr);
    }    
}

void change(int x)
{
    while(x)
    {
        add(1, id[top[x]], id[x]);
        x = father[top[x]];
    }
    if(x == 1) add(1, 1, 1);//如果不是0就会跳过1

}

int find(int x)
{
    rnt = 0;
    while(x)
    {
        search(1, id[top[x]], id[x]);
        x = father[top[x]];
    }
    if(x == 1) search(1, 1, 1); 
    return rnt;
}

void work()
{
    int x;
    for(R i = 1; i <= n; i++)
    {
        change(i);//修改i ---> root
        for(R j = E.Head[i]; j; j = E.Next[j])
        {
            x = E.date[j];//获取z
            ans[E.id[j]] = (find(x) - ans[E.id[j]]) % mod;
        }
    }
    for(R i = 1; i <= m; i++) printf("%d
", ans[i]);
}

int main()
{
//    freopen("in.in", "r", stdin);
    fread(READ, 1, 5000000, stdin);
    pre();
    dfs1(1);
    dfs2(1, 1);
    build(1, 1, n);
    work();
//    fclose(stdin);
    return 0;
}