HDU 5739 Fantasia(tarjan)

http://acm.hdu.edu.cn/showproblem.php?pid=5739
题意：给你n个点的一个图G，不一定连通，然后每个点都有权值，然后一个图的总价值就是每个连通图里面权值的乘积的和。
然后先在告诉你G1是去掉点1，之后剩下的图，G2是去掉点2之后剩下的。。。
就是要你把n个点分别去掉的情况的图的价值都算出来。

题解：这题去掉点之后，只有是割点，才会对连通图的数量产生影响，如果不是割点，那么只要原来连通图的价值除以这个点的就行了，如果是割点，那么就需要在tarjan的时候记录一些东西，shan[u]这个数组，记录的是如果u是割点，删除u的话，分散的几块连通图的乘积和，smul[u]记录分散的连通图的乘积的积，为啥要记录这个呢，因为如果你搜到一个点是割点，删除它之后，从上面搜下来的那部分也会分散，但是却不能把那部分算进shan[u]里面，所以需要后续的处理，所以需要记录这部分。割点的模版忘记了，wa了两次，dfs完之后就是对dfs到的割点再算一下，主要就是从上面搜下来的那一块，需要计算，$shan[u]+=mul*ni(a[u]*smul[u])$
最后求和的时候，如果这个点不是割点并且他在连通的里面只有一个的话，只要减不要加。
连通图有点忘记了，再去复习一下。
这题结合了dfs和割点，所以用tarjan来搞是比较好的

---

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           100005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const LL    mod    = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

struct Edge{
    int v,next;
}edge[MAX*4];
int head[MAX];
int tot;
int Index,cnt;
int dfn[MAX],low[MAX];
int instack[MAX];
int sstack[MAX];
int top;
int a[MAX];
int belong[MAX];
LL num[MAX];
LL shan[MAX];
LL smul[MAX];
vector<int> v[MAX];
bool ge[MAX];
int n,m;
LL mul;
void init(){
    for(int i=1;i<=n;i++){
        smul[i]=1;
        head[i]=-1;
        instack[i]=0;
        dfn[i]=0;
        shan[i]=0;
        ge[i]=false;
        v[i].clear();
    }
    tot=top=cnt=Index=0;
}


void add_edge(int a,int b){
    edge[tot]=(Edge){b,head[a]};
    head[a]=tot++;
}

LL qpow(LL a,LL n){
    LL ans=1;
    while(n){
        if(n&1) ans=ans*a%mod;
        a=a*a%mod;
        n>>=1;
    }
    return ans;
}

void tarjan(int u,int fa,int ance){
    dfn[u]=low[u]=++Index;
    instack[u]=1;
    sstack[++top]=u;
    int flag=0;
    mul=mul*a[u]%mod;
    int nf=0;
    v[cnt].push_back(u);
    for(int i=head[u];i!=-1;i=edge[i].next){
        int vv=edge[i].v;
        if(vv==fa&&!flag) {
            flag=1;
            continue;
        }
        if(!dfn[vv]){
            LL tmp=mul;
            tarjan(vv,u,ance);
            low[u]=min(low[u],low[vv]);
            if(low[vv]>=dfn[u]){
                nf++;
                LL temp=mul*qpow(tmp,mod-2)%mod;
                shan[u]=(shan[u]+temp)%mod;
                smul[u]=(smul[u]*temp)%mod;
            }
        }
        else if(instack[vv]) low[u]=min(dfn[vv],low[u]);
    }
    if(u==ance&&nf>=2||u!=ance&&nf>=1) ge[u]=1;
    if(dfn[u]==low[u]){
        while(1){
            int k=sstack[top--];
            instack[k]=0;
            belong[k]=cnt;
            if(k==u) break;
        }
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    int t;
    cin>>t;
    while(t--){
        cin>>n>>m;
        init();
        for(int i=1;i<=n;i++) RI(a[i]);
        for(int i=0;i<m;i++){
            int x,y;
            RI(x);RI(y);
            add_edge(x,y);
            add_edge(y,x);
        }
        LL ans=0;
        for(int i=1;i<=n;i++){
            if(!dfn[i]){
                mul=1;
                ++cnt;
                tarjan(i,-1,i);
                num[cnt]=mul;
                ans=ans+mul;
                if(ans>=mod) ans-=mod;
                for(int j=0;j<v[cnt].size();j++){
                    if(v[cnt][j]!=i){
                        int k=v[cnt][j];
                        shan[k]=shan[k]+num[cnt]*qpow(smul[k]*a[k]%mod,mod-2)%mod;
                        if(shan[k]>=mod) shan[k]-=mod;
                    }
                }
            }
        }
        LL ret=0;
        for(int i=1;i<=n;i++){
            LL tmp=0;
            if(!ge[i]){
                if(v[belong[i]].size()>1) tmp=(ans-num[belong[i]]+num[belong[i]]*qpow(a[i],mod-2)%mod+mod)%mod;
                else tmp=(ans-num[belong[i]]+mod)%mod;
            }
            else{
                tmp=(ans-num[belong[i]]+shan[i]+mod)%mod;
            }
            ret=(ret+i*tmp)%mod;
        }
        cout<<ret<<endl;
    }
    return 0;
}