[HDU 5739] Fantasia （点双联通分量 + Block Forest Data Structure）

HDU - 5739

给定一张无向图，每个点有个点权
一个图的权值计算为，现将同一联通分量的点权相乘
再将不同联通分量的点权相加
求图割去一个点后的权值

---

其中对于哪些非关节点，权值比较好计算
而对于关节点，割去之后图比较复杂
所以要用到一个叫做 Block Forest Data Structure的建图方式
首先求出图中的点双联通分量，
对于每一个点双，新建一个点向其中所有点连边
新图就会变成一个森林，其中非关节点是叶子节点，
而关节点和新建的点是内点
然后用树形统计一下每个点儿子的乘积和以及子树的乘积和
有一个trick就是有孤点的情况，孤点不会被记入点双，
所以特判一下，对于孤点直接计算答案即可

#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <map>
#include <set>
#include <queue>
#include <bitset>
using namespace std;
typedef pair<int,int> Pii;
typedef long long LL;
typedef unsigned long long ULL;
typedef double DBL;
typedef long double LDBL;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define SQR(a) ((a)*(a))
#define PCUT puts("----------")

const int maxn=2e5+10, maxm=2e5+10;
const LL MOD=1e9+7;
struct Graph
{
    int ndn, edn, last[maxn<<1];
    int u[maxm<<1], v[maxm<<1], nxt[maxm<<1];
    LL pval[maxn<<1], allw[maxn<<1];
    void init(int _n){ ndn=_n; edn=0; MST(last,-1); }
    void adde(int _u, int _v)
    {
        u[edn]=_u; v[edn]=_v;
        nxt[edn]=last[_u];
        last[_u]=edn++;
    }
};

struct Tarjan
{
    Graph *G;

    int dfst, dfsn[maxn], lowv[maxn];
    int dcc_cnt, skt, stak[maxn], iscut[maxn];
    bool ins[maxn];
    vector<int> dcc[maxn];
    int DCC();
    int dfs(int,int);

    int tot;
    int BlockForest();

    LL *ans, *cans, allw;
    LL sum[maxn<<1], pro[maxn<<1];
    bool vis[maxn];
    int solve(Graph*,LL*,LL*,LL);
    int calc(int,int);
};

int N,M;
Graph G;
Tarjan tar;
LL ans[maxn<<1], cans[maxn<<1], allw;

bool previs[maxn];
void precom(int,LL&);
int prevec[maxn], pcnt;
LL Pow(LL,LL,LL);

int main()
{
    #ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
    #endif

    int T;
    scanf("%d", &T);
    for(int ck=1; ck<=T; ck++)
    {
        scanf("%d%d", &N, &M);
        G.init(N);
        for(int i=1; i<=N; i++) scanf("%lld", &G.pval[i]);
        for(int i=0, u, v; i<M; i++)
        {
            scanf("%d%d", &u, &v);
            G.adde(u,v); G.adde(v,u);
        }
        CLR(ans); CLR(cans); CLR(previs); allw=0;

        for(int i=1; i<=N; i++) if(!previs[i])
        {
            pcnt=0;
            LL getv=1;
            precom(i,getv);
            for(int j=0; j<pcnt; j++) cans[prevec[j]] = getv;
            allw = (allw+getv)%MOD;
        }
        tar.solve(&G,ans,cans,allw);
        LL res=0;
        for(int i=1; i<=N; i++) res = (res+i*ans[i]%MOD)%MOD;
        printf("%lld\n", (res+MOD)%MOD);
    }
    return 0;
}

void precom(int u,LL &getv)
{
    previs[u]=1;
    getv = getv*G.pval[u]%MOD;
    prevec[pcnt++] = u;
    for(int e=G.last[u],v; ~e; e=G.nxt[e]) 
    {
        v=G.v[e]; if(previs[v]) continue;
        precom(v,getv);
    }
}

int Tarjan::solve(Graph *g, LL _ans[], LL _cans[], LL _allw)
{
    G = g;
    ans = _ans; cans=_cans, allw = _allw;
    DCC();
    BlockForest();
    CLR(vis);
    for(int i=1; i<=dcc_cnt; i++) if(!vis[i]) calc(tot+i,-1);
    return 0;
}

int Tarjan::calc(int u, int f)
{
    if(u>tot) vis[u-tot]=1;
    sum[u]=0;
    pro[u]=G->pval[u];
    for(int e=G->last[u],v; ~e; e=G->nxt[e])
    {
        v=G->v[e];
        if(v==f) continue;
        calc(v, u);
        sum[u] = (sum[u]+pro[v])%MOD;
        pro[u] = (pro[u]*pro[v])%MOD;
    }
    if(u<=tot) ans[u] = ((allw-cans[u])%MOD + sum[u] + cans[u]*Pow(pro[u], MOD-2, MOD)%MOD) %MOD;
    return 0;
}

int Tarjan::BlockForest()
{
    tot=G->ndn;
    G->init(tot+dcc_cnt);
    for(int i=1, u; i<=dcc_cnt; i++)
    {
        u=tot+i;
        G->pval[u] = 1;
        for(int j=0; j<(int)dcc[i].size(); j++)
        {
            G->adde(u, dcc[i][j]);
            G->adde(dcc[i][j], u);
        }
        dcc[i].clear();
    }
    return tot;
}

int Tarjan::DCC()
{
    dfst=0; CLR(dfsn); CLR(lowv);
    dcc_cnt=0; skt=0; CLR(stak); CLR(ins);
    CLR(iscut);

    for(int i=1; i<=G->ndn; i++) if(!dfsn[i]) dfs(i,-1);

    return 0;
}

int Tarjan::dfs(int u,int f)
{
    lowv[u] = dfsn[u] = ++dfst;
    int child=0;
    for(int e=G->last[u], v; ~e; e=G->nxt[e])
    {
        v=G->v[e];
        if(v==f) continue;
        child++;
        if(!dfsn[v])
        {
            stak[++skt] = e>>1;
            dfs(v,u);
            lowv[u] = min(lowv[u], lowv[v]);
            if(lowv[v] >= dfsn[u])
            {
                iscut[u]=1;
                ++dcc_cnt;
                do
                {
                    int te = stak[skt]<<1;
                    dcc[dcc_cnt].push_back(G->u[te]);
                    dcc[dcc_cnt].push_back(G->v[te]);
                } while( (e>>1) != stak[skt--]);
                sort(dcc[dcc_cnt].begin(), dcc[dcc_cnt].end());
                dcc[dcc_cnt].erase( unique(dcc[dcc_cnt].begin(), dcc[dcc_cnt].end()), dcc[dcc_cnt].end());
            }
        }
        else if(dfsn[v] < dfsn[u])
        {
            stak[++skt] = e>>1;
            lowv[u] = min(lowv[u], dfsn[v]);
        }
    }
    if(f==-1 && child<=1) iscut[u]=0;
    if(f==-1 && child==0)
    {
        ans[u] = (allw-G->pval[u])%MOD;
    }
    return 0;
}

LL Pow(LL x, LL n, LL p)
{
    LL res=1;
    while(n)
    {
        if(n&1) res=res*x%p;
        x=x*x%p;
        n>>=1;
    }
    return res%p;
}