HDU 4612 Warm up

Warm up

                                                   Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
                                                                     Total Submission(s): 1269    Accepted Submission(s): 285

Problem Description

　　N planets are connected by M bidirectional channels that allow instant transportation. It's always possible to travel between any two planets through these channels.
　　If we can isolate some planets from others by breaking only one channel , the channel is called a bridge of the transportation system.
People don't like to be isolated. So they ask what's the minimal number of bridges they can have if they decide to build a new channel.
　　Note that there could be more than one channel between two planets.

Input

　　The input contains multiple cases.
　　Each case starts with two positive integers N and M , indicating the number of planets and the number of channels.
　　(2<=N<=200000, 1<=M<=1000000)
　　Next M lines each contains two positive integers A and B, indicating a channel between planet A and B in the system. Planets are numbered by 1..N.
　　A line with two integers '0' terminates the input.

Output

　　For each case, output the minimal number of bridges after building a new channel in a line.

Sample Input

  
  

   
   4 4
1 2
1 3
1 4
2 3
0 0 
  
  

Sample Output

  
  

   
   0
  
  

Source

2013 Multi-University Training Contest 2

Recommend

zhuyuanchen520
我对这题的理解：
  （1）把这题看做是有向图来处理，比较方便。求出强连通快，强连通快内自然没有桥。这时候桥的个数是联通快的个数-1，然后缩点，求树的直径，相减得结果。
 （2）如果是看做无向图来处理的话，就要求他的边双连通分量。可以通过先求桥，然后再遍历一遍，路径不经过桥，从而得出边双连通分量的个数，然后缩点，求树的直径，sum(桥)-len(直径)得出结果。
    可以看出如果把此图当做是无向图来处理的话，比较麻烦。
  有向图强连通分量实现：

#include <iostream>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <cmath>
#define N 200010
#define M 2000010
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n,m;
struct link
{
    int e,next,id;
}a[M],c[M];
int dfn[N],low[N],b[N],d[N],cnt[N],cou,Top,id,Max;
bool instack[N],flag[M];
stack<int> sta;
int main()
{
    //freopen("data1.in","r",stdin);
    void addeage(int y,int id,link* p,int* p1);
    void tarjan(int u);
    int bfs(int k);
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
        {
            break;
        }
        memset(b,-1,sizeof(b));
        while(!sta.empty())
        {
            sta.pop();
        }
        Top = 0;
        for(int i=1;i<=m;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            addeage(y,i,&a[Top],&b[x]);
            addeage(x,i,&a[Top],&b[y]);
        }
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        memset(instack,false,sizeof(instack));
        memset(flag,false,sizeof(flag));
        cou = 0;
        id = 0;
        int ans1=0;
        queue<int> q;
        for(int i=1;i<=n;i++)
        {
            if(!dfn[i])
            {
                id = 0;
                while(!sta.empty())
                {
                    sta.pop();
                }
                tarjan(i);
                q.push(i);
                ans1 += (id-1);
            }
        }
        memset(d,-1,sizeof(d));
        Top=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=b[i];j!=-1;j=a[j].next)
            {
                int x = a[j].e;
                if(cnt[i]!=cnt[x])
                {
                    int u = cnt[i];
                    int v = cnt[x];
                    addeage(v,0,&c[Top],&d[u]);
                    addeage(u,0,&c[Top],&d[v]);
                }
            }
        }
        int ans2=0;
        while(!q.empty())
        {
            int x = q.front();
            q.pop();
            int k = bfs(x);
            bfs(k);
            ans2 = max(ans2,Max);
        }
        printf("%d\n",ans1 - ans2);
    }
    return 0;
}
void addeage(int y,int id,link* p,int* p1)
{
    (*p).e = y;
    (*p).id = id;
    (*p).next = *p1;
    *p1 = Top;
    Top++;
}
void tarjan(int u)
{
    low[u] = dfn[u] = ++cou;
    sta.push(u);
    instack[u] = true;
    for(int i = b[u]; i!=-1; i = a[i].next)
    {
        int v = a[i].e;
        if(flag[a[i].id])
        {
            continue;
        }
        flag[a[i].id] = true;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u],low[v]);
        }else if(instack[v])
        {
            low[u] = min(low[u],dfn[v]);
        }
    }
    if(low[u] == dfn[u])
    {
        id++;
        int x;
        do
        {
            x = sta.top();
            sta.pop();
            instack[x] = false;
            cnt[x] = id;
        }while(x!=u);
    }
}
int bfs(int k)
{
    queue<int> que;
    memset(dfn,0,sizeof(dfn));
    que.push(k);
    Max = 0;
    int key=k,pre=k;
    while(!que.empty())
    {
        int x = que.front();
        que.pop();
        for(int i = d[x]; i!=-1; i=c[i].next)
        {
            int y = c[i].e;
            if(!dfn[y]&&y!=pre)
            {
                dfn[y] = dfn[x] + 1;
                que.push(y);
                if(dfn[y]>Max)
                {
                    Max = dfn[y];
                    key = y;
                }
            }
        }
    }
    return key;
}

无向图边双连通分量实现：

#include <iostream>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <cmath>
#define N 200010
#define M 2000010
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n,m;
struct link
{
    int e,next,id;
}a[M],c[M];
int dfn[N],low[N],b[N],d[N],cnt[N],cou,Top,id,Max,ans1;
bool instack[N],flag[M],br[M];
int main()
{
    //freopen("data1.in","r",stdin);
    void addeage(int y,int id,link* p,int* p1);
    void tarjan(int u,int fa);
    int bfs(int k);
    void dfs(int k);
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
        {
            break;
        }
        memset(b,-1,sizeof(b));
        Top = 0;
        for(int i=1;i<=m;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            addeage(y,i,&a[Top],&b[x]);
            addeage(x,i,&a[Top],&b[y]);
        }
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        memset(instack,false,sizeof(instack));
        memset(flag,false,sizeof(flag));
        memset(br,false,sizeof(br));
        cou = 0;
        queue<int> q;
        ans1 = 0;
        for(int i=1;i<=n;i++)
        {
            if(!dfn[i])
            {
                tarjan(i,-1);
                q.push(i);
            }
        }
        id = 0;
        for(int i=1;i<=n;i++)
        {
            if(!instack[i])
            {
                id++;
                dfs(i);
            }
        }
        memset(d,-1,sizeof(d));
        Top=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=b[i];j!=-1;j=a[j].next)
            {
                int x = a[j].e;
                if(cnt[i]!=cnt[x])
                {
                    int u = cnt[i];
                    int v = cnt[x];
                    addeage(v,0,&c[Top],&d[u]);
                    addeage(u,0,&c[Top],&d[v]);
                }
            }
        }
        int ans2=0;
        while(!q.empty())
        {
            int x = q.front();
            q.pop();
            int k = bfs(x);
            bfs(k);
            ans2 = max(ans2,Max);
        }
        printf("%d\n",ans1 - ans2);
    }
    return 0;
}
void addeage(int y,int id,link* p,int* p1)
{
    (*p).e = y;
    (*p).id = id;
    (*p).next = *p1;
    *p1 = Top;
    Top++;
}
void tarjan(int u,int fa)
{
    low[u] = dfn[u] = ++cou;
    for(int i = b[u]; i!=-1; i = a[i].next)
    {
        int v = a[i].e;
        if(flag[a[i].id])
        {
            continue;
        }
        flag[a[i].id] = true;
        if(!dfn[v])
        {
            tarjan(v,u);
            low[u] = min(low[u],low[v]);
            if(low[v]>dfn[u])
            {
                br[a[i].id] = true;
                ans1+=1;
            }
        }else if(dfn[v]<dfn[u])
        {
            low[u] = min(low[u],dfn[v]);
        }
    }
}
int bfs(int k)
{
    queue<int> que;
    memset(dfn,0,sizeof(dfn));
    que.push(k);
    Max = 0;
    int key=k,pre=k;
    while(!que.empty())
    {
        int x = que.front();
        que.pop();
        for(int i = d[x]; i!=-1; i=c[i].next)
        {
            int y = c[i].e;
            if(!dfn[y]&&y!=pre)
            {
                dfn[y] = dfn[x] + 1;
                que.push(y);
                if(dfn[y]>Max)
                {
                    Max = dfn[y];
                    key = y;
                }
            }
        }
    }
    return key;
}
void dfs(int k)
{
    instack[k] = true;
    cnt[k] = id;
    for(int i=b[k];i!=-1;i=a[i].next)
    {
        int x = a[i].e;
        if(!instack[x]&&!br[a[i].id])
        {
            dfs(x);
        }
    }
}