hdu 5739 Fantasia(Tarjan,割点)

参考题解：http://blog.csdn.net/cqu_hyx/article/details/51995638
搜hdu的点双连通分量的题目，搜到了这个，先上点双的模板，修修改改后发现根本用不到点双，求出来割点，预处理下Gi就可以了。但是修修改改好几个小时一直过不去，不是wa就是tle，总有处理不好的地方。庆幸搜到的题解和自己思路差不多，看起来很省力。

思路：

• 整个图不一定是连通的，先计算出连通分量个数，计算出每个连通分量的节点权值的乘积。
• 对每个连通分量Tarjan求割点，在Tarjan的同时，对每个节点，计算Gi
  
  • 如果这个点不是割点，直接从总权值中去掉当前点所在连通分量的权值，然后用当前连通分量的权值在除去当前点的权值，再和其与连通分量权值加和。
  • 如果这个点是割点，从总权值中去除割点所在连通分量，然后对于割点，计算出去除割点后形成的点双连通分量的点权值乘积的加和。然后再计算出割点父节点那些节点的权值的乘积，再与这些点双的加和相加。再与其与连通分量加和即可。
  • 注意对只有一个节点的连通分量的处理

对比下别人代码，自己漏掉的东西好多啊

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 15;
const int MAXM = 1e6 + 15;
typedef long long LL;
const LL mod = 1e9 + 7;

struct Edge
{
    int to, next;
} edge[MAXM];
int head[MAXN];
int Dfn[MAXN], Low[MAXN], book[MAXN];
LL weight[MAXN], ans[MAXN], value[MAXN];
LL Sum;
int tot,Index,cur;

template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if(c=getchar(),c==EOF) return 0; //EOF
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}


LL modPow(LL a, LL b)
{
    LL ret = 1;
    while(b)
    {
        if(b&1) ret = ret*a%mod;
        a = a*a%mod;
        b >>= 1;
    }
    return ret;
}

LL inv(LL x)
{
    return modPow(x, mod - 2);
}

void addedge(int u, int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void init()
{
    Sum = Index = tot = 0;
    memset(book, 0, sizeof(book));
    memset(Dfn, 0, sizeof(Dfn));
    memset(head, -1, sizeof(head));
}

void dfs(int u)
{
    value[u] = weight[u];
    for(int i = head[u]; ~i; i = edge[i].next)
    {
        int v = edge[i].to;
        if(book[v]) continue;
        book[v] = true;
        dfs(v);
        value[u] = value[u] * value[v] % mod;
    }
}

LL Tarjan(int u, int fa)
{
    LL ret = weight[u], sum = 0, pro = weight[u];
    Dfn[u] = Low[u] = ++Index;
    int child = 0, fg = 0;
    for(int i = head[u]; ~i; i = edge[i].next)
    {
        int v = edge[i].to;
        if(!Dfn[v])
        {
            child++;
            LL tmp = Tarjan(v, u);
            Low[u] = min(Low[u], Low[v]);
            if(fa < 0) sum = (sum + tmp)%mod;
            if(fa < 0 && child > 1) fg = 1;
            if(fa != -1 && Low[v] >= Dfn[u])
            {
                sum = (sum + tmp)%mod;
                //pro计算的是去掉割点后的那些形成的连通分量的(包括当前割点)
                pro = pro * tmp % mod;
                fg = 1;
            }
            //ret计算的是子树的
            ret = ret * tmp % mod;
        }
        else if(v != fa)
            Low[u] = min(Low[u], Dfn[v]);
    }

    if(!fg)
    {
        if(fa < 0 && head[u] == -1)
            ans[u] = (Sum - value[cur] + mod) % mod;
        else
            ans[u] = ((Sum - value[cur] + mod) % mod + value[cur] * inv(weight[u]) % mod) % mod;
    }
    else
    {
        LL pre = value[cur] * inv(pro) % mod;
        if(fa != -1) sum = (sum + pre)%mod;
        ans[u] = (Sum - value[cur] + mod) % mod;
        ans[u] = (ans[u] + sum)%mod;
    }
    return ret;
}

int vec[MAXN];

void solve(int n)
{
    int vlen = 0;
    for(int i = 1; i <= n; i++)
    {
        if(book[i]) continue;
        vec[vlen++] = i;
        book[i] = true;
        dfs(i);
        Sum = (Sum+value[i])%mod;
    }
    for(int i = 0; i < vlen; i++)
    {
        cur = vec[i];
        Tarjan(vec[i],-1);
    }
    LL S = 0;
    for(int i = 1; i <= n; i++)
        S = (S + ans[i]*i%mod)%mod;
    printf("%I64d\n", S);
}

int main()
{
    int t,u,v,n,m;
    scan_d(t);
    while(t--)
    {
        scan_d(n);
        scan_d(m);
        init();
        for(int i = 1; i <= n; i++)
            scan_d(weight[i]);
        for(int i = 1; i <= m; i++)
        {
            scan_d(u);
            scan_d(v);
            addedge(u, v);
            addedge(v, u);
        }
        solve(n);
    }
    return 0;
}