倍增lca-ZJOI2012 灾难

一个食物网有N个点，代表N种生物，如果生物x可以吃生物y，那么从y向x连一个有向边。这个图没有环。图中有一些点没有连出边，这些点代表的生物都是生产者，可以通过光合作用来生存； 而有连出边的点代表的都是消费者，它们必须通过吃其他生物来生存。如果某个消费者的所有食物都灭绝了，它会跟着灭绝。我们定义一个生物在食物网中的“灾难值”为，如果它突然灭绝，那么会跟着一起灭绝的生物的种数。现在请你求出每一个物种的“灾难值”。

　　首先思考：什么情况下一个物种会灭绝？也就是所有它能吃的东西灭绝了，它就灭绝了。所以如果要让物种A灭绝，我们可以选一个物种B，使得物种A所有能吃的东西都灭绝。我们定义”灭绝树”，其中一个节点的父亲是能让它灭绝的深度最低的结点。不难发现灭绝树上A的祖先灭绝后，A一定灭绝。所以若要让物种x，y一起灭绝，只需查询它们所有父亲在灭绝树上的lca即可。

　　这道题做了三天。。最后用cyaron对拍出来，发现是一个以前写的模块忘记改回来了。。以后写程序就要一口气写完，不要被外界干扰。

 #include <cmath>
 #include <queue>
 #include <cstdio>
 #include <cstring>
 using namespace std;

 const int maxn=;

 int first1[maxn], first2[maxn], topo[maxn], topo2[maxn], out[maxn];
 int fa[maxn][], dep[maxn], size[maxn], ans[maxn];
 struct Edge{
     int v, to, next;
 };
 Edge edges1[maxn], edges2[maxn];

 int n, cnte1, cnte2;

 void addedge(int *first, Edge *edges, int &cntedge,
              int v, int from, int to){
     edges[cntedge].v=v;
     edges[cntedge].to=to;
     edges[cntedge].next=first[from];
     first[from]=cntedge;
     cntedge++;
     return;
 }

 double log2(int x){
     return log(x)/log();
 }

 int get_lca(int x, int y){
     int t=, step=;
     if (dep[x]<dep[y]) swap(x, y);
     t=dep[x]-dep[y];
     while (t){
         if (t&) x=fa[x][step];
         t>>=;
         ++step;
     }
     for (int step=; step>; --step){
         if (fa[x][step]!=fa[y][step]){
             x=fa[x][step];
             y=fa[y][step];
         }
     }
     if (x!=y) x=fa[x][];
     return x;
 }

 int main(){
     for (int i=; i<maxn; ++i) first1[i]=first2[i]=-;
     scanf("%d", &n);
     for (int i=; i<=n; ++i){
         int t;
         scanf("%d", &t);
         while (t) {
             addedge(first1, edges1, cnte1, , i, t);
             addedge(first2, edges2, cnte2, , t, i);
             ++out[i];
             scanf("%d", &t);
         }
     }
     queue<int> q;
     for (int i=; i<=n; ++i){
         if (!out[i]){
             addedge(first1, edges1, cnte1, , i, );
             addedge(first2, edges2, cnte2, , , i);
             out[i]=;
         }
     }
     //以上：读入、加边
     q.push();
     int nownode, nowedge, nowson;
     for (int i=; i<=n; ++i){
         nownode=q.front();
         q.pop();
         topo[i]=nownode;
         nowedge=first2[nownode];
         while (nowedge!=-){
             nowson=edges2[nowedge].to;
             if (!--out[nowson]){
                 q.push(nowson);
             }
             nowedge=edges2[nowedge].next;
         }
     }
     //以上：拓扑排序
     int lca=, cur=;
     for (int i=; i<=n; ++i){
         nownode=topo[i];
         nowedge=first1[nownode];
         lca=nowson=edges1[nowedge].to;
         nowedge=edges1[nowedge].next;
         while (nowedge!=-){
             nowson=edges1[nowedge].to;
             //if (!nowedge) break; !!!!
             lca=get_lca(lca, nowson);
             nowedge=edges1[nowedge].next;
         }
         dep[nownode]=dep[lca]+;
         cur=;
         fa[nownode][cur]=nownode;
         fa[nownode][++cur]=lca;
         ++size[lca];
         while (fa[nownode][cur]){
             fa[nownode][cur+]=fa[fa[nownode][cur]][cur];
             ++cur;
         }
     }
     //以上：建立灭绝树
     while (!q.empty()) q.pop();
     for (int i=; i<=n; ++i){
         ans[i]=;
         if (size[i]==) q.push(i);
     }
     int fath;
     for (int i=n; i>; --i){
         nownode=q.front();
         q.pop();
         fath=fa[nownode][];
         --size[fath];
         if (!size[fath]) q.push(fath);
         ans[fath]+=ans[nownode];
     }
     //以上：统计size
     for (int i=; i<=n; ++i)
         printf("%d\n", ans[i]-);
     return ;
 }

附：用来对拍的python程序。

 from cyaron import *
 from random import randint

 for n in range(5, 11):
     input_io = IO()
     for i in range(0, 100):
             #对于n，生成100个数据。
         input_io.input_writeln(n)
         print(n) ###
         topo = Vector.random(n, [(1, n)], 0)
         for j in topo:
             print(j, end=' ') ###
             #拓扑序
         print() ###
         m = randint(n*2, n*3)
             #有多少个边(有一些边会被舍弃掉)
         out = []
         for j in range(0, n):
             out.append(0)
             #每个结点的出度(吃什么)
         for j in range(0, m):
             t = randint(0, n-1)
             if out[t] < t / 2:
                 out[t] += 1
         graph = []
         for j in range(0, n):
             graph.append([])
         for j in range(1, n):
             #对于每一个结点
             use = []
                 #连了哪些结点
             for k in range(0, n):
                 use.append(0)
             for k in range(0, out[j]):
                 #对于要连的边
                 node = randint(0, j-1)
                 while use[node] == 1:
                     node = randint(0, j-1)
                 use[node] = 1
                 #选一个点
                 graph[topo[j][0]-1].append(topo[node][0])
         for j in graph:
             for k in j:
                 #print(k, end=" ")
                 input_io.input_write(k)
             #print(0)
             input_io.input_writeln(0)
         Compare.program("mine.exe", input=input_io,
                         std_program="yangs.exe", stop_on_incorrect=True)