模拟赛-仙人球 Tarjan+树链剖分

题目描述

如果一个无自环无重边无向连通图的任意一个点最多属于一个简单环，我们就称之为仙人球。所谓简单环即不经过重复的结点的环。

现在，小Z有一张仙人球图，他想知道两个点之间不同的非复杂路径的条数。这里复杂路径指的是经过某条边至少两次的路径，两条路径不同当且仅当它们之中的边不同。这个问题太难了，所以小Z想要请教请教你。当然，为了不让你特别尴尬，你只需要求出条数mod 1000000007的值即可

输入
第1行：两个整数：n、m，分别代表仙人球图的点数和边数
第2~m+1行：每行两个整数xi、yi，表示xi和yi之间有一条边
第m+2行：一个整数k，表示询问个数
第m+3~m+k+2行：每行两个整数ai、bi，表示小G的询问

输出
输出k行，每行一个整数，为ai到bi的不同的非复杂路径的条数mod 1000000007的值。

样例输入
10 11
1 2
2 3
3 4
1 4
3 5
5 6
8 6
8 7
7 6
7 9
9 10
6
1 2
3 5
6 9
9 2
9 3
9 10
样例输出
2
2
2
4
4
1
提示

样例解释

画图易看出询问1、3、4、6的答案；询问2有两种方案：3->5和3->4->1->2->3->5，这里应注意3->4->1->2->3->5和3->2->1->4->3->5是同一条路径；询问5同理。

数据范围与约定

对于15%的数据，n、m、k≤30
对于40%的数据，n、m、k≤500
对于70%的数据，n、m、k≤2000
对于100%的数据，n、k≤100000，m≤150000，数据保证给出的是一张仙人球图，保证每个询问的ai≠bi。

感觉这题好神啊..
两个点非复杂路径条数$= 2^i$，其中 i <script type="math/tex" id="MathJax-Element-44">i</script>为这两个点之间环的数量，Tarjan缩点后树剖统计就好了

早期辣眼睛代码QAQ：

#include<algorithm>
#include<ctype.h>
#include<cstdio>
#define N 100050
#define MOD 1000000007
using namespace std;
typedef long long LL;
LL quick_pow(int x,int k){
    LL sum;
    for(sum=1;k;k>>=1,x=(1ll*x*x)%MOD)
        if(k&1) sum=(1ll*sum*x)%MOD;
    return sum;
}
inline int read(){
    char c=getchar();
    int x=0,f=1;
    while(!isdigit(c)) {if(c=='-') f=-1;c=getchar();}
    while(isdigit(c)) {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*f;
}
int n,m,k,x,y,top,topp,scc_cnt,T;
int fir[N],Fir[N],sccfir[N],dfn[N],low[N],belong[N],s[N],d[N];
int dep[N],fa[N],son[N],size[N],Top[N],tree[N],pre[N*10];
bool b[N*10];
struct Edge{
    int to,nex;
    Edge(int _=0,int __=0):to(_),nex(__){}
}nex[150000*3],scc[150000*3],Nex[150000*3];
inline void add(int x,int y){
    Nex[++top]=Edge(y,Fir[x]);
    Fir[x]=top;
}
inline void Add(int x,int y){
    for(int i=fir[x];i;i=nex[i].nex) if(nex[i].to==y) return;
    nex[++top]=Edge(y,fir[x]);
    fir[x]=top;
}
inline void addd(int x,int y){
    scc[++top]=Edge(y,sccfir[x]);
    sccfir[x]=top;
}
void Tarjan(int x,int fa){
    dfn[x]=low[x]=++T;
    s[++topp]=x;b[x]=true;
    for(int i=Fir[x];i;i=Nex[i].nex){
        if(Nex[i].to==fa) continue;
        if(!dfn[Nex[i].to]){
            Tarjan(Nex[i].to,x);
            low[x]=min(low[x],low[Nex[i].to]);
        }
        else if(b[Nex[i].to]) low[x]=min(low[x],low[Nex[i].to]);
    }
    if(dfn[x]==low[x]){
        scc_cnt++;
        int v,cnt=0;
        do{
            if(cnt++) d[scc_cnt]=1;
            v=s[topp--];
            b[v]=false;
            addd(scc_cnt,v);
            belong[v]=scc_cnt;
        }while(v!=x);
    }
}
void dfs1(int x,int Fa,int Dep){
    dep[x]=Dep;fa[x]=Fa;
    size[x]=1;
    for(int i=fir[x];i;i=nex[i].nex){
        if(nex[i].to==Fa) continue;
        dfs1(nex[i].to,x,Dep+1);
        size[x]=size[x]+size[nex[i].to];
        if(size[nex[i].to]>size[son[x]]) son[x]=nex[i].to;
    }
}
void dfs2(int x,int top){
    Top[x]=top;
    tree[x]=++T;pre[T]=x;
    if(!son[x]) return;
    dfs2(son[x],top);
    for(int i=fir[x];i;i=nex[i].nex){
        if(nex[i].to==fa[x] || nex[i].to==son[x]) continue;
        dfs2(nex[i].to,nex[i].to);
    }
}
struct Seg{
    int sum,l,r;
}a[N*4];
void maketree(int l,int r,int k){
    a[k].l=l;a[k].r=r;
    if(l==r){
        a[k].sum=d[pre[l]];
        return;
    }
    int mid=(l+r)>>1;
    maketree(l,mid,2*k);maketree(mid+1,r,2*k+1);
    a[k].sum=(a[2*k].sum)+(a[2*k+1].sum);
}
int Query_Sum(int x,int y,int k){
    if((a[k].l)>=x && (a[k].r)<=y){
        return (a[k].sum);
    }
    int mid=((a[k].l)+(a[k].r))>>1;
    if(mid>=y) return Query_Sum(x,y,2*k);
    if(mid<x) return Query_Sum(x,y,2*k+1);
    return Query_Sum(x,y,2*k)+Query_Sum(x,y,2*k+1);
}
int Find_sum(int x,int y){
    int sum=0;
    while(Top[x]!=Top[y]){
        if(dep[Top[x]]<dep[Top[y]]) swap(x,y);
        int t=Query_Sum(tree[Top[x]],tree[x],1);
        sum=sum+t;
        x=fa[Top[x]];
    }
    if(tree[x]>tree[y]) swap(x,y);
    sum=sum+Query_Sum(tree[x],tree[y],1);
    return sum;
}
main(){
    n=read();m=read();
    for(int i=1;i<=m;i++){
        add(x=read(),y=read());add(y,x);
    }
    top=0;
    for(int i=1;i<=n;i++){
        topp=0;
        if(!dfn[i]) Tarjan(i,0);
    }
    top=0;
    for(int i=1;i<=n;i++)
        for(int j=Fir[i];j;j=Nex[j].nex){
            if(belong[i]==belong[Nex[j].to]) continue;
            Add(belong[i],belong[Nex[j].to]);
            Add(belong[Nex[j].to],belong[i]);
        }
    T=0;top=1;
    dfs1(1,0,1);dfs2(1,1);
    maketree(1,n,1);
    k=read();
    for(int i=1;i<=k;i++){
        x=read();y=read();
        int t=Find_sum(belong[x],belong[y]);
        printf("%lld\n",quick_pow(2,t));
    }
return 0;
}