HDU 5420 Victor and Proposition

Victor and Proposition

Time Limit: 6000ms

Memory Limit: 524288KB

This problem will be judged on HDU. Original ID: 5420
64-bit integer IO format: %I64d      Java class name: Main

At the very beginning, Victor has a proposition, then this proposition procudes many propositions. Then every proposition procudes more propositions...... Finally there are n propositions. These propositions can be regarded as a tree whose root is 1.

We assume that the first proposition, whose number is 1, belongs to the 0-th generation, and those propositions produced by the x-th generation belong to the x+1-th generation. We also assume that all of the propositions in the x-th generation are in level x. Specially, Victor has discovered that the proposition whose number is i can infer the proposition whose number is xi and all of the propositions in xi's subtree, whose levels are not greater than xi's level + di.

Notice : a is b's father does not show that either a can infer b or b can infer a.

Now please determine the number of such ordered pairs (i,j), that 1≤i<j≤n, the proposition i can infer the proposition j, and the proposition j can also infer the proposition i.

Input
The first line of the input contains an integer T, denoting the number of test cases.

In every test case, there is an integer n in the first line, denoting the number of the propositions.

The second line contains n−1 integers, the i-th integer fi+1(fi<i) denotes that the proposition i+1 is produced by the proposition fi+1.

Then there are n lines, the i-th line contains two integers xi and di.

1≤T≤5.

2≤n≤100000.

0≤di<n.

Output
Your program should print T lines : the i-th of these should contain a single integer, denoting the number of such ordered pairs (i,j).

Sample Input
1
4
1 2 1
2 1
1 0
4 0
2 0

Sample Output
6

Source
BestCoder Round #52 (div.2)

解题：线段树优化建图，妙哉，内存开得好凶残，吓呆本宝宝了

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 typedef pair<int,int> pii;
 const int INF = 0x3f3f3f3f;
 const int maxn = ;
 struct arc {
     int to,next;
     arc(int x = ,int y = -) {
         to = x;
         next = y;
     }
 } e[(+)**];
 int head[maxn],L[maxn],R[maxn],tot,clk;
 int dep[maxn],hs[maxn],st[maxn],n;
 vector<pii>order[maxn];
 void add(int u,int v) {
     e[tot] = arc(v,head[u]);
     head[u] = tot++;
 }
 void init() {
     tot = ;
     memset(head,-,sizeof head);
 }
 void dfs(int u,int depth) {
     hs[L[u] = ++clk] = u;
     dep[u] = depth;
     for(int i = head[u]; ~i; i = e[i].next) dfs(e[i].to,depth + );
     R[u] = clk;
 }
 void build(int L,int R,int v) {
     order[v].resize(R - L + );
     if(L == R) {
         st[v] = ++n;
         order[v][] = pii(dep[hs[L]],hs[L]);
         add(n,hs[L]);
         return;
     }
     int mid = (L + R)>>;
     build(L,mid,v<<);
     build(mid + ,R,v<<|);
     st[v] = n + ;
     merge(order[v<<].begin(),order[v<<].end(),order[v<<|].begin(),order[v<<|].end(),order[v].begin());
     for(int i = ; i <= R - L; ++i)
         add(n + i + , n + i);
     for(int i = ; i <= R - L; ++i)
         add(n + i + ,order[v][i].second);
     n += R - L + ;
 }
 void connect(int L,int R,int lt,int rt,int u,int d,int v) {
     if(lt <= L && rt >= R) {
         int pos = lower_bound(order[v].begin(),order[v].end(),pii(d,INF)) - order[v].begin() - ;
         if(~pos) add(u,st[v] + pos);
         return;
     }
     int mid = (L + R)>>;
     if(lt <= mid) connect(L,mid,lt,rt,u,d,v<<);
     if(rt > mid) connect(mid + ,R,lt,rt,u,d,v<<|);
 }
 int dfn[maxn],low[maxn],cnt[maxn],scc,ct;
 bool instack[maxn];
 stack<int>stk;
 void tarjan(int u) {
     dfn[u] = low[u] = ++ct;
     instack[u] = true;
     stk.push(u);
     for(int i = head[u]; ~i; i = e[i].next) {
         if(!dfn[e[i].to]) {
             tarjan(e[i].to);
             low[u] = min(low[u],low[e[i].to]);
         } else if(instack[e[i].to]) low[u] = min(low[u],dfn[e[i].to]);
     }
     if(low[u] == dfn[u]) {
         int v;
         cnt[++scc] = ;
         do {
             instack[v = stk.top()] = false;
             stk.pop();
             cnt[scc] += (v <= clk);
         } while(v != u);
     }
 }
 int main() {
     int kase,u,v;
     scanf("%d",&kase);
     while(kase--) {
         scanf("%d",&n);
         init();
         clk = scc = ct = ;
         memset(dfn,,sizeof dfn);
         memset(instack,false,sizeof instack);
         for(int i = ; i <= n; ++i) {
             scanf("%d",&u);
             add(u,i);
         }
         dfs(,);
         init();
         build(,clk,);
         for(int i = ; i <= clk; ++i) {
             scanf("%d%d",&u,&v);
             connect(,clk,L[u],R[u],i,dep[u] + v,);
         }
         for(int i = ; i <= n; ++i)
             if(!dfn[i]) tarjan(i);
         LL ret = ;
         for(int i = ; i <= scc; ++i)
             ret += (LL)cnt[i]*(cnt[i]-)/;
         printf("%I64d\n",ret);
     }
     return ;
 }