F - Warm up - hdu 4612(缩点+求树的直径)

题意：有一个无向连通图，现在问添加一条边后最少还有几个桥

分析：先把图缩点，然后重构图为一棵树，求出来树的直径即可，不过注意会有重边，构树的时候注意一下

***********************************************************************

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
 
const int MAXN = 2e5+;
 
struct Edge{int v, vis, next;}e1[MAXN*], e2[MAXN*];
int Head1[MAXN], Head2[MAXN], cnt[], fa[MAXN];
void AddEdge(Edge e[], int Head[], int u, int v, int k)
{
    e[ cnt[k] ].v = v;
    e[ cnt[k] ].vis = ;
    e[ cnt[k] ].next = Head[u];
    Head[u] = cnt[k]++;
}
 
struct node{int u, step;};
node BFS(node s, int k)
{
    queue<node> Q;
    Q.push(s);
 
    while(Q.size())
    {
        s = Q.front();Q.pop();
 
        for(int j=Head2[s.u]; j!=-; j=e2[j].next)
        {
            node q = s;
            q.u = e2[j].v;
 
            if(e2[j].vis != k)
            {
                e2[j].vis = e2[j^].vis = k;
                q.step++;
                Q.push(q);
            }
        }
 
    }
 
    return s;
}
 
int dfn[MAXN], low[MAXN], Index;
int belong[MAXN], bnt;
int Stack[MAXN], top;
 
void InIt(int N)
{
    cnt[] = cnt[] = Index = bnt = top = ;
    for(int i=; i<=N; i++)
    {
        Head1[i] = Head2[i] = -;
        dfn[i] = ;
        fa[i] = ;
    }
}
void Tarjan(int u)
{
    int v;
 
    low[u] = dfn[u] = ++Index;
    Stack[++top] = u;
 
    for(int j=Head1[u]; j!=-; j=e1[j].next)
    {
        v = e1[j].v;
        if(e1[j].vis == false)
        {
            e1[j].vis = e1[j^].vis = true;
            if( !dfn[v] )
            {
                Tarjan(v);
                low[u] = min(low[u], low[v]);
            }
            else
                low[u] = min(low[u], dfn[v]);
        }
    }
 
    if(low[u] == dfn[u])
    {
        ++bnt;
        do
        {
            v = Stack[top--];
            belong[v] = bnt;
        }
        while(u != v);
    }
}
int main()
{
    int N, M;
 
    while(scanf("%d%d", &N, &M), N+M)
    {
        int i, j, u, v;
 
        InIt(N);
 
        while(M--)
        {
            scanf("%d%d", &u, &v);
            AddEdge(e1, Head1, u, v, );
            AddEdge(e1, Head1, v, u, );
        }
 
        Tarjan();
 
        for(i=; i<=N; i++)
        for(j=Head1[i]; j!=-; j=e1[j].next)
        {
            v = e1[j].v;
            u = belong[i], v = belong[v];
            if(u > v && fa[v] != u)
            {
                fa[v] = u;
                AddEdge(e2, Head2, u, v, );
                AddEdge(e2, Head2, v, u, );
            }
        }
 
        node s;
        s.u = , s.step = ;
 
        s = BFS(s, );
        s.step = ;
        s = BFS(s, );
 
        printf("%d\n", bnt-s.step-);
    }
 
    return ; }