[Codeforces 231E] Cactus （环缩点+LCA）

Codeforces - 231E

给定一个仙人掌图，问从 x点走到 y点有多少条路径

两条不同的路径必须每一条边都不相同

写了这个图论，相当于写了一个模拟

本来都是贴板的事，但是到仓库一看我并没有板

可能当初觉得很简单就没留板……

所以全程手写了，而且实际上我对图论并不是很熟

幸好不是在赛上，不然手速肯定被完爆

x到 y的路径，经过每个环的时候，就有两种走法

做法就是用边双联通分量对于每一个环缩成一个点，

每个大小大于 1的环权值为 2，否则就是 1

然后就变成了一棵树，预处理出根到每一点路径的前缀权值乘积

答案就是 x和y的前缀权值乘积，除两次lca(x,y)的前缀权值乘积，再乘一次 lca的权值

#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>
#include <string>
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("\n----------")
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;
}
const int maxn=1e5+10;
const int MOD=1e9+7;
struct Graph
{
int ndn, edn, last[maxn];
int u[2*maxn], v[2*maxn], nxt[2*maxn];
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], iscut[2*maxn];
int col[maxn], nc;
LL pval[maxn], pvalr[maxn];
int que[2*maxn], firp[maxn], idfsn[maxn], tail;
int st[20][2*maxn];

int solve(Graph*);
int dfs(int,int);
int color(int);
int precom(int,int,LL);
void st_init();
int LCA(int,int);
};

int N,M;
Graph G;
Tarjan tar;

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

while(~scanf("%d%d", &N, &M))
{
G.init(N);
for(int i=0,u,v; i<M; i++)
{
scanf("%d%d", &u, &v);
G.adde(u,v); G.adde(v,u);
}
tar.solve(&G);
}
return 0;
}

int Tarjan::solve(Graph *g)
{
G=g;
dfst=0; CLR(dfsn); CLR(lowv); CLR(iscut);
dfs(1,0);

nc=0; CLR(col); CLR(pval);
for(int i=1; i<=G->ndn; i++) if(!col[i]) {nc++; pval[nc]=color(i);}
for(int i=1; i<=nc; i++) if(pval[i]>2) pval[i]=2;

int tot=G->edn;
G->init(nc);
for(int e=0, u, v; e<tot; e++)
{
u = G->u[e], v = G->v[e];
if(col[u]!=col[v]) G->adde(col[u], col[v]);
}

dfst=0; tail=0; CLR(dfsn); CLR(firp);
precom(1,0,1);
st_init();

int K;
scanf("%d", &K);
for(int i=0,x,y,l; i<K; i++)
{
scanf("%d%d", &x, &y);
x=col[x], y=col[y];
l=LCA(x,y);
int ans = pvalr[x]*pvalr[y]%MOD * Pow(SQR(pvalr[l])%MOD, MOD-2, MOD)%MOD * pval[l]%MOD;
printf("%d\n", ans);
}

}

int Tarjan::dfs(int u, int f)
{
lowv[u] = dfsn[u] = ++dfst;

for(int e=G->last[u], v; ~e; e=G->nxt[e])
{
v=G->v[e];
if(v==f) continue;
if(!dfsn[v])
{
lowv[u] = min(lowv[u], dfs(v,u));
if(lowv[v] > dfsn[u]) iscut[e] = iscut[e^1] = 1;
}
else lowv[u] = min(lowv[u], dfsn[v]);
}
return lowv[u];
}
int Tarjan::color(int u)
{
int cnt=1;
col[u] = nc;
for(int e=G->last[u], v; ~e; e=G->nxt[e])
{
v=G->v[e];
if(col[v] || iscut[e]) continue;
cnt+=color(v);
}
return cnt;
}
int Tarjan::precom(int u,int f,LL prod)
{
dfsn[u]=++dfst;
idfsn[dfst] = u;
pvalr[u] = pval[u]*prod%MOD;
que[++tail] = dfsn[u];
firp[u] = tail;
for(int e=G->last[u],v; ~e; e=G->nxt[e]) if((v=G->v[e])!=f)
{
precom(v,u,pvalr[u]);
que[++tail] = dfsn[u];
}
}
void Tarjan::st_init()
{
for(int i=1; i<=tail; i++) st[0][i] = que[i];
for(int j=1, lim, len; j<=20; j++)
{
len=1<<j-1; lim=tail-(1<<j)+1;
for(int i=1; i<lim; i++)
{
st[j][i] = min(st[j-1][i], st[j-1][i+len]);
}
}
}

int Tarjan::LCA(int x, int y)
{
x=firp[x], y=firp[y];
if(x>y) swap(x,y);
int flr=log2(y-x+1), len=1<<flr;
return idfsn[ min(st[flr][x], st[flr][y-len+1]) ];
}