HDU 4612 Warm up

Warm up

Time Limit: 5000ms

Memory Limit: 65535KB

This problem will be judged on HDU. Original ID: 4612
64-bit integer IO format: %I64d      Java class name: Main

　　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

 

解题：类似于network那题。。。边双连通+树的直径

此题严重爆栈。。。只能用微软的编译器

 

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
const int maxn = 200010;
struct arc{
    int to,next;
    arc(int x = 0,int y = -1){
        to = x;
        next = y;
    }
}e[4000000];
int head[maxn],hd[maxn],dfn[maxn],low[maxn],belong[maxn];
int scc,idx,tot,n,m,d[maxn];
bool instack[maxn];
stack<int>stk;
void add(int *head,int u,int v){
    e[tot] = arc(v,head[u]);
    head[u] = tot++;
}
void tarjan(int u,int fa){
    dfn[u] = low[u] = ++idx;
    instack[u] = true;
    stk.push(u);
    bool flag = true;
    for(int i = head[u]; ~i; i = e[i].next){
        if(e[i].to == fa && flag){
            flag = false;
            continue;
        }
        if(!dfn[e[i].to]){
            tarjan(e[i].to,u);
            low[u] = min(low[u],low[e[i].to]);
        }else if(instack[e[i].to]) low[u] = min(low[u],dfn[e[i].to]);
    }
    if(low[u] == dfn[u]){
        scc++;
        int v;
        do{
            instack[v = stk.top()] = false;
            stk.pop();
            belong[v] = scc;
        }while(v != u);
    }
}
void init(){
    for(int i = 0; i < maxn; ++i){
        head[i] = hd[i] = -1;
        belong[i] = low[i] = dfn[i] = 0;
        instack[i] = false;
    }
    idx = scc = tot = 0;
    while(!stk.empty()) stk.pop();
}
queue<int>q;
int bfs(int u){
    while(!q.empty()) q.pop();
    memset(d,-1,sizeof(d));
    d[u] = 0;
    q.push(u);
    while(!q.empty()){
        u = q.front();
        q.pop();
        for(int i = hd[u]; ~i; i = e[i].next){
            if(d[e[i].to] == -1){
                d[e[i].to] = d[u] + 1;
                q.push(e[i].to);
            }
        }
    }
    int maxV = 0,idx = u;
    for(int i = 1; i <= scc; ++i)
        if(d[i] > maxV) maxV = d[idx = i];
    return idx;
}
int main(){
    int u,v;
    while(scanf("%d %d",&n,&m),n||m){
        init();
        for(int i = 0; i < m; ++i){
            scanf("%d %d",&u,&v);
            add(head,u,v);
            add(head,v,u);
        }
        tarjan(1,-1);
        for(int i = 1; i <= n; ++i)
        for(int j = head[i]; ~j; j = e[j].next){
            if(belong[i] != belong[e[j].to])
                add(hd,belong[i],belong[e[j].to]);
        }
        printf("%d\n",scc - 1 - d[bfs(bfs(1))]);
    }
    return 0;
}

 

很容易想到树的直径就是某一点到两个最长点的和。。。

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
const int maxn = 200010;
struct arc {
    int to,next;
    arc(int x = 0,int y = -1) {
        to = x;
        next = y;
    }
} e[4000000];
int head[maxn],dfn[maxn],low[maxn],belong[maxn];
int scc,idx,tot,n,m,dp[maxn][2];
bool instack[maxn];
stack<int>stk;
void add(int *head,int u,int v) {
    e[tot] = arc(v,head[u]);
    head[u] = tot++;
}
void tarjan(int u,int fa) {
    dfn[u] = low[u] = ++idx;
    instack[u] = true;
    stk.push(u);
    dp[u][0] = dp[u][1] = 0;
    bool flag = true;
    for(int i = head[u]; ~i; i = e[i].next) {
        if(e[i].to == fa && flag) {
            flag = false;
            continue;
        }
        if(!dfn[e[i].to]) {
            tarjan(e[i].to,u);
            low[u] = min(low[u],low[e[i].to]);
            int tmp = dp[e[i].to][1] + (low[e[i].to] > dfn[u]);
            if(tmp > dp[u][1]) {
                swap(dp[u][1],dp[u][0]);
                dp[u][1] = tmp;
            } else if(tmp > dp[u][0]) dp[u][0] = tmp;
        } else if(instack[e[i].to]) low[u] = min(low[u],dfn[e[i].to]);
    }
    if(low[u] == dfn[u]) {
        scc++;
        int v;
        do {
            instack[v = stk.top()] = false;
            stk.pop();
            belong[v] = scc;
        } while(v != u);
    }
}
void init() {
    for(int i = 0; i < maxn; ++i) {
        head[i] = -1;
        belong[i] = low[i] = dfn[i] = 0;
        instack[i] = false;
    }
    idx = scc = tot = 0;
    while(!stk.empty()) stk.pop();
}
int main() {
    int u,v;
    while(scanf("%d %d",&n,&m),n||m) {
        init();
        for(int i = 0; i < m; ++i) {
            scanf("%d %d",&u,&v);
            add(head,u,v);
            add(head,v,u);
        }
        tarjan(1,-1);
        int ans = 0;
        for(int i = 1; i <= n; ++i)
            ans = max(ans,dp[i][1] + dp[i][0]);
        printf("%d\n",scc - 1 - ans);
    }
    return 0;
}