hdu4612Warm up tarjan+树形dp

//给一个连通无向图

//定义去除一条边即能使得一个点与其他点不连通的边为桥

//问加一条边后最少有几个桥

//用tarjan对该无向图进行缩点

//由于该无向图是一个连通图，所以缩点后其为一棵树，数的节点个数为num

//该树的所有边都是桥

//要加一条边使得桥最少，只需要将这条边加在这棵树的直径r的两个端点上

//即最终的最少桥的个数为num-1-r

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<vector>

#include<queue>

#include<map>

#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std ;

const int maxm = 1000100 ;

const int maxn = 200010 ;

struct Edge

{

int v ;int u ;

int next ;

}edge[maxm*2];

int head[maxn] ;

int nedge ;

vector<int> vec[maxn] ;

void addedge(int u , int v)

{

edge[nedge].v = v ;

edge[nedge].u = u ;

edge[nedge].next = head[u] ;

head[u] = nedge++ ;

}

int dfn[maxn] , low[maxn] , belong[maxn] ;

int step , num ,top;

int n , m ;int ans ;

int stack[maxn] , isstack[maxn] , vis[maxm*2];

int dp[maxn][2] ;

void init()

{

memset(dfn , 0 ,sizeof(dfn)) ;

memset(isstack , 0 ,sizeof(isstack)) ;

memset(head , -1 , sizeof(head)) ;

memset(vis , 0 , sizeof(vis)) ;

memset(dp , 0 , sizeof(dp)) ;

for(int i = 0 ;i < maxn;i++)

vec[i].clear() ;

step = num = nedge = top = 0 ;

}

void tarjan(int u)

{

stack[++top] = u ;

isstack[u] = 1;

dfn[u] = low[u] = ++step;

for(int i = head[u] ;i != -1 ; i = edge[i].next)

{

if(vis[i])continue ;

vis[i^1] = vis[i] = 1; //遍历完一条边将该边和其反向边标记

int v = edge[i].v ;

if(!dfn[v])

{

tarjan(v) ;

low[u] = min(low[u] , low[v]) ;

}

else if(isstack[v])

low[u] = min(low[u] , dfn[v]) ;

}

if(low[u] == dfn[u])

{

num++ ;

int v = 0;

while(u!=v)

{

v = stack[top--] ;

belong[v] = num ;

isstack[v] = 1;

}

}

}

void build_tree()

{

int sum = 0 ;

for(int i = 0;i < 2*m;i+=2)

{

int v = belong[edge[i].v];

int u = belong[edge[i].u];

if(u!=v)

{

vec[u].push_back(v) ;

vec[v].push_back(u) ;

}

}

}

//dp[u][1],dp[u][0] 分别表示以u节点为根节点的子树与其最远和第二远的节点的距离

void dfs(const int u , int &ans)

{

vis[u] = 1 ;

for(int i = 0;i < vec[u].size();i++)

{

int v = vec[u][i];

if(vis[v])continue ;

dfs(v , ans);

if(dp[v][1] + 1 > dp[u][1])

{

dp[u][0] = max(dp[u][0] , dp[u][1]);

dp[u][1] = dp[v][1] + 1 ;

}

else dp[u][0] = max(dp[u][0] , dp[v][1] + 1);

}

ans = max(ans , dp[u][0] + dp[u][1]) ;

}

//一棵树的直径可以通过两次bfs找到

//一次从任意结点开始，找与其距离最大的点，然后从该点开始，

//再一次遍历到与其最远的节点的距离即为该树的直径

/*queue<int> que ;

int bfs( const int st , int &ans)

{

while(que.size())que.pop() ;

que.push(st) ;

que.push(0) ;

vis[st] = 1 ;

int en = st;

ans = 0 ;

while(que.size())

{

int u = que.front() ;que.pop() ;

int step = que.front();que.pop() ;

if(step > ans)

{

ans = step;

en = u ;

}

for(int i = 0;i < vec[u].size() ;i++)

{

int v = vec[u][i] ;

if(vis[v])continue ;

vis[v] = 1 ;

que.push(v);

que.push(step+1);

}

}

return en ;

}*/

int main()

{

//freopen("in.txt" , "r" , stdin) ;

while(scanf("%d%d" , &n , &m) , n+m)

{

init() ;

for(int i = 1;i <= m;i++)

{

int a , b ;

scanf("%d%d" , &a , &b) ;

addedge(a , b) ;

addedge(b , a) ;

}

tarjan(1) ;

build_tree() ;

int ans = 0 ;

memset(vis , 0 ,sizeof(vis)) ;

dfs(1 , ans) ;

//bfs(bfs(1 , ans) , ans);

printf("%d\n" , num - 1 - ans) ;

}

return 0 ;

}