倍增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=1000000;

int first1[maxn], first2[maxn], topo[maxn], topo2[maxn], out[maxn];
int fa[maxn][30], 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(2);
}

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

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

附：用来对拍的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)