[LNOI2014]LCA

嘟嘟嘟

不得不说，这道题出的真是太好了！

正解直接说出来太突兀了，还是先从暴力开始。

首先，如果看到题目就像怎么求LCA，那就凉凉（也不想想，省选题会在题目中告诉你做法吗？！）。

除非有一种方法一次把LCA都求出来，或者是把这个求多个deep的和转化一下。

反正第一种方法我是不会。

至于求多个deep的和，我们从整体上考虑：每一个LCA对答案的贡献多少。我们发现，z的LCA一定在z到根节点的路径上，而且deep[u]就是u到根节点经过的节点数目。所以我们可以把每一个LCA到根节点的的路径中的所有点权值都加1，然后从z跑一边加上路径上的点的贡献即可。

所以对于一组查询[L, R] 和z，可以枚举 i (i :L ~ R) 。然后给 i 到根的路径每一个点都加1，最后z在跑一边统计即可。又因为是树上路径的操作，可以用树剖维护。复杂度O(q * n * (logn)²)。

考虑怎么优化：对于查询区间[L, R]，用前缀和的思想[L, R] = [1, R] - [1, L - 1]。可以先求出[1, L - 1]的答案，然后求出[1, R]的答案，最后相减即可。于是我们把所有答案离线下来，开一个标记数组sec，给sec[L - 1]和sec[R]标记。然后从1到n扫，每一次都把 i 到根的路径权值加1，如果sec[i]有标记，就查询一下，累加到这个询问的答案中。

然后注意一下细节：

1.标记数组要开一个vector，因为区间端点可能重复。

2.标记有这么几个参数：id ： 询问编号, flg ： -1表示做端点，要减去；1表示区间右端点，要加上, z : 就是题中的z。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 5e4 + 5;
const int mod = 201314;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, q;
vector<int> v[maxn];

int fa[maxn], dep[maxn], siz[maxn], son[maxn];
void dfs1(int now)
{
    siz[now] = 1;
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        dep[v[now][i]] = dep[now] + 1;
        fa[v[now][i]] = now;
        dfs1(v[now][i]);
        siz[now] += siz[v[now][i]];
        if(!son[now] || siz[son[now]] < siz[v[now][i]]) son[now] = v[now][i];
    }
}
int dfsx[maxn], pos[maxn], top[maxn], cnt = 0;
void dfs2(int now)
{
    dfsx[now] = ++cnt; pos[cnt] = now;
    if(son[now])
    {
        top[son[now]] = top[now];
        dfs2(son[now]);
    }
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(v[now][i] != son[now])
        {
            top[v[now][i]] = v[now][i];
            dfs2(v[now][i]);
        }
    }
}

void Mod(int& x)
{
    if(x > mod) x -= mod;
}

int l[maxn << 2], r[maxn << 2], sum[maxn << 2], lzy[maxn << 2];
void build(int L, int R, int now)
{
    l[now] = L; r[now] = R;
    if(L == R) return;
    int mid = (L + R) >> 1;
    build(L, mid, now << 1);
    build(mid + 1, R, now << 1 | 1);
}
void pushdown(int now)
{
    if(lzy[now])
    {
        sum[now << 1] += lzy[now] * (r[now << 1] - l[now << 1] + 1); Mod(sum[now << 1]);
        sum[now << 1 | 1] += lzy[now] * (r[now << 1 | 1] - l[now << 1 | 1] + 1); Mod(sum[now << 1 | 1]);
        lzy[now << 1] += lzy[now]; Mod(lzy[now << 1]);
        lzy[now << 1 | 1] += lzy[now]; Mod(lzy[now << 1 | 1]);
        lzy[now] = 0;
    }
}
void update(int L, int R, int now)
{
    if(L == l[now] && R == r[now]) 
    {
        sum[now] += R - L + 1; lzy[now]++;
        Mod(sum[now]); Mod(lzy[now]);
        return;
    }
    pushdown(now);
    int mid = (l[now] + r[now]) >> 1;
    if(R <= mid) update(L, R, now << 1);
    else if(L > mid) update(L, R, now << 1 | 1);
    else update(L, mid, now << 1), update(mid + 1, R, now << 1 | 1);
    sum[now] = sum[now << 1] + sum[now << 1 | 1]; Mod(sum[now]);
}
int query(int L, int R, int now)
{
    if(L == l[now] && R == r[now]) return sum[now];
    pushdown(now);
    int mid = (l[now] + r[now]) >> 1;
    if(R <= mid) return query(L, R, now << 1);
    else if(L > mid) return query(L, R, now << 1 | 1);
    else return (query(L, mid, now << 1) + query(mid + 1, R, now << 1 | 1)) % mod;
}

void update_path(int x)
{
    while(top[x] != 1)
    {        
        update(dfsx[top[x]], dfsx[x], 1);
        x = fa[top[x]];
    }
    update(dfsx[1], dfsx[x], 1);
}
int query_path(int x)
{
    int ret = 0;
    while(top[x] != 1)
    {
        ret += query(dfsx[top[x]], dfsx[x], 1);
        Mod(ret);
        x = fa[top[x]];
    }
    ret += query(dfsx[1], dfsx[x], 1); Mod(ret);
    return ret;
}

struct Node
{
    int id, flg, z;        
};
vector<Node> sec[maxn];
int ans[maxn];

int main()
{
    n = read(); q = read();
    for(int i = 2; i <= n; ++i)
    {
        int x = read() + 1;
        v[x].push_back(i);
    }
    dfs1(1); top[1] = 1; dfs2(1);
    build(1, cnt, 1);
    for(int i = 1; i <= q; ++i) 
    {
        int L = read(), R = read(), z = read();
        L++; R++; z++;
        sec[L - 1].push_back((Node){i, -1, z});
        sec[R].push_back((Node){i, 1, z});
    }
    for(int i = 1; i <= n; ++i)
    {
        update_path(i);
        for(int j = 0; j < (int)sec[i].size(); ++j)
        {
            Node x = sec[i][j];
            ans[x.id] += x.flg * query_path(x.z);
            (ans[x.id] += mod) %= mod;
        }
    }
    for(int i = 1; i <= q; ++i) write(ans[i]), enter;
    return 0;
}