CF 178B3 Greedy Merchants

最新推荐文章于 2025-07-03 17:13:07 发布

原创最新推荐文章于 2025-07-03 17:13:07 发布 · 810 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#codeforces #LCA #BCC #双连通分量

maple_图论同时被 2 个专栏收录

4 篇文章

订阅专栏

CodeForces

3 篇文章

订阅专栏

本文解析了Codeforces上的一道经典题目B3，通过双连通分量分解的方法求解给定图中两点间桥的数量。介绍了如何利用LCA算法优化求解过程。

题目链接：http://codeforces.com/problemset/problem/178/B3

题目描述：

现给定n个节点（1～n）与m条无向边边（n,m <= 10^5），然后给定k（k<= 10^5个询问，每个询问包含两个节点（a，b），保证a，b可达，求a，b间的桥的数量。

这题其实也算是比较经典的模板题，对于该无向图求桥，一般用的就是双连通分量分解，参照了网上的一个分解模板，分解之后，那么可以将每个连通分量看成一个节点，构造一颗树，那么树之间就是用桥相连的，那么对于同一个连通分量中，桥的数量就是0了，如果是不同的连通分量，那么求桥的数量其实就可以转化到求解LCA问题上面了，求一次LCA是log n, 这里就是n log n，比如说求解a，b之间的桥的数量，那么就是从a到a与b的最近公共祖先，然后在回到b，这里经过的边数，其实就是：

dep[ a ] + dep[ b ] - 2 * ( dep[ LCA(a, b) ] )，画下图应该会更容易理解。

#include<cstdio>
#include<iostream>
#include<vector>
#include<stack>
#include<cstring>
using namespace std ;

const int MAXM = 1e5+5 ;
const int MAXN = 20 ;
int n, m, k ;
vector<int> G[MAXM], rG[MAXM] ;
//
int root ;
int parent[MAXN][MAXM] ;
int dep[MAXM] ;
pair<int,int> bridge[MAXM] ;
int pre[MAXM], bccNo[MAXM], bccTime, bccNum, bccBriNum ; //bccNo记录的是节点序号对应的连通分量号
stack<int> s ;
//对边的双连通分量
//
int deal(int u, int fa){
	int lowu = pre[u] = ++bccTime ;
	s.push(u) ;
	for( int i = 0; i < G[u].size(); i++ ){
		int v = G[u][i] ;
		if( !pre[v] ){
			int lowv = deal(v, u) ;
			lowu = min(lowu, lowv) ;
			if( lowv > pre[u] ){
				bridge[bccBriNum++] = make_pair(u, v) ;
			}
		}else if( pre[v] < pre[u] && v != fa ){
			lowu = min(lowu, pre[v]) ;
		}
	}	
	if( lowu == pre[u] ){
        bccNum++;
        while(1){
             int x = s.top() ;
			 s.pop() ;
             bccNo[x] = bccNum ;
             if(x == u)  break ; 
        }
     }
     return lowu ;
}
//
void bcc(){
	memset(pre,0,sizeof(pre)) ;
	bccTime = bccNum = bccBriNum = 0 ;
	deal(1,-1) ;
}
//
//LCA
//
void dfs(int v, int p, int d){
	parent[0][v] = p ;		
	dep[v] = d ;
	for( int i = 0; i < rG[v].size(); i++ ){
		if( rG[v][i] != p )	dfs(rG[v][i], v, d+1) ; 
	}
}
//
void init(int V){
	root = 1 ;
	dfs(root, -1, 1) ;
	for( int k = 0; k+1 < MAXN; k++ ){
		for( int j = 1; j <= V; j++ ){
			int v = bccNo[j] ;
			if( parent[k][v] < 0 )	parent[k+1][v] = -1 ;
			else	parent[k+1][v] = parent[k][parent[k][v]] ;
		} 
	}
}
//
int lca(int u, int v){
	if( dep[u] > dep[v] )	swap(u,v) ;
	for( int k = 0; k < MAXN; k++ ){
		if( (dep[v]-dep[u]) >> k & 1 ){
			v = parent[k][v] ;
		}
	} 
	if( u == v )	return u ;
	for( int k = MAXN-1; k >= 0; k-- ){
		if( parent[k][u] != parent[k][v] ){
			u = parent[k][u] ;
			v = parent[k][v] ;
		}
	}
	return parent[0][u] ;
}
//
int main(){
	//freopen("1234.in","r",stdin) ;
	scanf("%d%d",&n,&m) ;
	for( int i = 0; i < m; i++ ){
		int a, b ;
		scanf("%d%d",&a,&b) ;
		G[a].push_back(b) ;
		G[b].push_back(a) ;
	}
	//
	bcc() ;
	//重新构成树
	for( int i = 0; i < bccBriNum;i++ ){
		int a = bridge[i].first ;
        int b = bridge[i].second ;
        rG[bccNo[a]].push_back(bccNo[b]) ;
        rG[bccNo[b]].push_back(bccNo[a]) ;
	}
	init(n) ;
	//
	scanf("%d",&k) ;
	for( int i = 0; i < k; i++ ){
		int a, b ;
		scanf("%d%d",&a,&b) ;
		int t1 = bccNo[a], t2 = bccNo[b] ;	
		printf("%d\n",dep[t1]+dep[t2]-2*dep[lca(t1,t2)]) ;
	}
	return 0 ;
}