GYM：Jakanda Forever（LCA + BIT）

J. Jakanda Forever

time limit per test

2.0 s

memory limit per test

256 MB

input

standard input

output

standard output

In East Hackerland, there is a country called Jakanda which possesses highly advanced technology. It consists of $N$ cities and $N-1$bidirectional roads. Each road has its own length and connects two cities. It is possible to travel from a city to any other city via these roads.

The Black Panda, king of Jakanda, is facing a problem. Some of the cities are having riot. A city under riot would send out a rebel army and try to capture one other city ("targeted city"). Black Panda is not going to let it happen. He would send a scout from the targeted city to the city under riot. Both the rebel and scout will walk for 1 mile toward their own destination during the day and rest at night. The scout would only spot the rebel army only if they are at the same location and it is at night. If the scout fails to spot the army, the rebel army would capture its target city.

Other than the riot, the length of some of the roads in Jakanda would change due to damage of the war.

Now there are $Q$ events in chronological order. Each event is one of the two types:

1 $u$ $v$, which denote city $u$ is now under riot and is sending a rebel army to capture city $v$. Note that city $v$ might have rebellion or captured before, but in these cases we would consider Black Panda had already suppressed it.

2 $i$ $l$, which denote the $i^{th}$ road is now changed to length $l$.

For each type 1 event, output JAKANDA FOREVER if the scout could spot the rebels, output WE NEED BLACK PANDA otherwise.

Input

The first line contains a single integer $N$, the number of cities ($1\le N\le 5\times {10}^5$).

The following $N-1$ lines contains the roads information, each line contains three integers: $u_i$, $v_i$ and $l_i$, which means the $i^{th}$ road connect city $u_i$ and $v_i$ with length of $l_i$ miles ($1\le u_i,v_i\le N$; $u_i\ne v_i$; $1\le l_i\le {10}^9$).

Then a single line is followed, which contains a single integer $Q$ ($1\le Q\le 5\times {10}^5$).

The following $Q$ lines contains the event information, each line contains three integer. The first integer $type$ denote the event type.

For $type=1$, two integers, $u$ $v$ is followed. $u$ is the city under riot and $v$ is the target city ($1\le u,v\le N$; $u\ne v$).

For $type=2$, two integers, $i$ $l$ is followed. It means the $i^{th}$ road's length is changed to $l$ miles.

Output

For each type 1 event, output JAKANDA FOREVER if the scout is going to spot the rebels, WE NEED BLACK PANDA otherwise.

Example

input

Copy

4
1 2 3
1 3 4
4 1 5
5
1 1 2
1 2 3
2 1 2
1 2 1
1 4 2

output

Copy

WE NEED BLACK PANDA
WE NEED BLACK PANDA
JAKANDA FOREVER
WE NEED BLACK PANDA

Note

The structure of Jakanda before the third event:

The structure of Jakanda after the third event:

题意：简化了就是给一棵带边权树，Q个询问，1 x y表示判断x点到y点的路径长度的奇偶性，2 x y表示将第x条边的权值设置为y。

思路：一开始想到树剖，但是题目只需讨论奇偶性，那么就不用这么麻烦了。首先假设无修改操作，那么用LCA（dep[x]+dep[y]-2*dep[lca(x,y)]）可以简单处理，对于2 x y操作，设x的深度比y大，那么可以将x的子树的点权全部加1，这样子的话，对于1 x y操作，我们把x和y的点权加起来，再加上前面LCA预处理的部分就可以判断奇偶性了。其实就是修改x y的边权（假设修改成奇偶性相反）会造成位于边x y两边的点对路径的奇偶性都发生变化，因此通过DFS序 + BIT(差分思想)或者线段树可以搞定子树的批量赋值。复杂度：查询和修改都是常数*O(logn)

# include <bits/stdc++.h>
# define pb push_back
# define mp make_pair
using namespace std;
const int maxn = 5e5+30;
int cnt = 0, fa[maxn][21]={0}, h[maxn]={0}, in[maxn]={0}, out[maxn]={0};
int dep[maxn]={0}, sum[maxn]={0};
vector<pair<int,int> >g[maxn];
struct edge
{
    int u, v, w;
}edge[maxn];
void dfs(int cur, int pre)
{
    in[cur] = ++cnt;
    fa[cur][0] = pre;
    for(int i=1; (1<<i)<=h[cur]; ++i)
        fa[cur][i] = fa[fa[cur][i-1]][i-1];
    for(int i=0; i<g[cur].size(); ++i)
    {
        int to = g[cur][i].first;
        if(to != pre)
        {
            h[to] = h[cur] + 1;
            dep[to] = dep[cur] + g[cur][i].second;
            dfs(to, cur);
        }
    }
    out[cur] = cnt;
}
int lca(int v, int u)
{
    if(h[v] > h[u]) swap(v, u);
    for(int i=0; i<20; ++i)
        if(h[u]-h[v]>>i & 1)
        u = fa[u][i];
    for(int i=20; i>=0; --i)
        if(fa[v][i] != fa[u][i])
            v = fa[v][i], u=fa[u][i];
    return v == u?v:fa[v][0];
}
int cal(int pos)
{
    int res = 0;
    for(int i=pos; i>0; i-=i&-i)
        res += sum[i];
    return res;
}
void update(int pos, int num)
{
    for(int i=pos; i<=cnt; i+=i&-i)
        sum[i] += num;
}
int main()
{
    int n, q, x, y, z;
    scanf("%d",&n);
    for(int i=1; i<n; ++i)
    {
        scanf("%d%d%d",&x,&y,&z);
        g[x].pb(mp(y,z&1));
        g[y].pb(mp(x,z&1));
        edge[i] = {x, y, z&1};
    }
    dfs(1, 0);
    scanf("%d",&q);
    while(q--)
    {
        int op;
        scanf("%d",&op);
        if(op == 1)
        {
            scanf("%d%d",&x,&y);
            int old = dep[x] + dep[y] - 2*dep[lca(x,y)];
            int now = cal(in[x]) + cal(in[y]);
            if((old+now)&1) puts("WE NEED BLACK PANDA");
            else puts("JAKANDA FOREVER");
        }
        else
        {
            scanf("%d%d",&x,&y);
            int old = edge[x].w, u = edge[x].u, v = edge[x].v;
            if(h[v] < h[u]) swap(u,v);
            if(old != (y&1))
            {
                update(in[v], 1);
                update(out[v]+1, -1);
                edge[x].w = y&1;
            }
        }
    }
    return 0;
}