HDU 4612 Warm up (边双连通分量+树的直径)

HDU - 4612 

题目大意：给出一个无向连通图，问加一条边最少还剩多少条割边。

解题思路:求边双联通分量之后缩点后是一颗树，然后求树的直径就是减少的桥。

本来挺简单一个题目，因为vis数组开小了各种wa tle 。。。伤心啊。。。。

还好收获了新姿势。。

求树的直径一般有两种方法，两次bfs或者dfs 还有就是树形dp

dp[u][0] 和dp[u][1] 分别代表以u为根的最长和次长路径。（最长和次长路径一定不一样。）

在回溯的时候我们先判断能不能更新，最长路径，能更新的话原来次长的值为当前最长，再更新当前最长

否则的话判断能否更新次长。最终答案为最max(dp[u][1]+dp[u][0])

解法一：求边连通分量缩点后两次dfs求出答案。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<stack>
#include<map>
#include<algorithm>
using namespace std;
#define LL long long
#pragma comment(linker, "/STACK:102400000,102400000")
#define sca(x) scanf("%d",&x)
#define lowb(x) (x&(-x))
#define pb(x) push_back(x)
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define per(i,j,k) for(int i=j;i>=k;i--)
#define pri(x) printf("%d\n",x);
#define N 200005
#define inf 0x3f3f3f3f
const LL mod=1e9+7;

struct node
{
    int to,nt,id,flag;
}g[N*10];

int head[N];
vector<int>G[N];
int tot;
void addedg(int x,int y,int id,bool tt)
{
    g[tot].to=y;
    g[tot].id=id;
    g[tot].flag=tt;
    g[tot].nt=head[x];
    head[x]=tot++;
}

int low[N],df[N];
int bel[N],vis[N*10];
int clo,cnt;
int lef;
void dfs(int now,int fa)
{
    df[now]=low[now]=++clo;
    for(int i=head[now];i+1;i=g[i].nt)
    {
        int to=g[i].to;
        if(g[i].flag==false)continue;//处理重边。
        g[i].flag=g[i^1].flag=false;
        if(!df[to])
        {
            dfs(to,now);
            low[now]=min(low[now],low[to]);
            if(low[to]>df[now])
            {
                vis[g[i].id]=1;
            }
        }
        else low[now]=min(low[now],df[to]);
    }
}

void dfs1(int u)//再一次遍历求出边双联通分量
{
    bel[u]=cnt;
    for(int i=head[u];i+1;i=g[i].nt)
    {
        if(!vis[g[i].id]&&!bel[g[i].to])
        {
            dfs1(g[i].to);
        }
    }
}

int F[N],vis1[N];
int dia,beg;
void Find(int now,int tmp)//两次dfs求出树的直径
{
    for(int i=0;i<G[now].size();i++)
    {
        int to=G[now][i];
        if(vis1[to])continue;
        vis1[to]=1;
        F[to]=tmp+1;
        if(F[to]>dia)
        {
            dia=F[to];
            beg=to;
        }
        Find(to,F[to]);
    }
}
void solve(int n)
{
    dfs(1,-1);
    cnt=1;
    rep(i,1,n)if(!bel[i])dfs1(i),cnt++;
    rep(i,1,n)
    {
        for(int j=head[i];j+1;j=g[j].nt)
        {
            if(bel[i]!=bel[g[j].to])
            {
                G[bel[i]].pb(bel[g[j].to]);
                G[bel[g[j].to]].pb(bel[i]);
            }
        }
    }
    cnt--;
    vis1[1]=1;
    Find(1,0);
    memset(vis1,0,sizeof(vis1));
    dia=0;
    vis1[beg]=1;
    Find(beg,0);
    //cout<<cnt-1<<" "<<dia<<endl;
    printf("%d\n",cnt-1-dia);
}

void init(int n)
{
    tot=0,lef=0;
    clo=0,cnt=0;
    dia=0;
    memset(head,-1,sizeof(head));
    rep(i,1,N)G[i].clear();
    memset(df,0,sizeof(df));
    memset(low,0,sizeof(low));
    memset(bel,0,sizeof(bel));
    memset(vis,0,sizeof(vis));
    memset(F,0,sizeof(F));
    memset(vis1,0,sizeof(vis1));
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0)break;
        init(n);
        rep(i,1,m)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            addedg(x,y,i,true);
            addedg(y,x,i,true);
        }
        solve(n);
    }
}

解法二：学习了别人的做法，在求割边的时候利用树形dp求出直径和桥。

因为回溯的时候如果是割边的话就相当去是树上的边此时可以更新dp值，感觉这样做应该是对的，具体原理不清楚。

可能是缩点后的树形图和原来的深搜生成树以相似的，所以才可以这样做吧。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<algorithm>
using namespace std;
#define LL long long
#define sca(x) scanf("%d",&x)
#define lowb(x) (x&(-x))
#define pb(x) push_back(x)
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define per(i,j,k) for(int i=j;i>=k;i--)
#define pri(x) printf("%d\n",x);
#define N 200015
#define inf 0x3f3f3f3f
const LL mod=1e9+7;


struct node
{
    int to,nt;
}g[N*10];

int tot,bridge;
int clo,ans;
int low[N],df[N];
bool vis[N*10];
int dp[N][2];
int head[N];
void addedg(int x,int y)
{
    g[tot].to=y;
    g[tot].nt=head[x];
    head[x]=tot++;
}

void init(int n)
{
    clo=0,bridge=0;
    tot=0,ans=0;
    memset(vis,false,sizeof(vis));
    rep(i,0,n)
    {
        dp[i][0]=dp[i][1]=0;
        head[i]=-1;
        df[i]=low[i]=0;
    }

}

void tarjan(int u)
{
    low[u]=df[u]=++clo;
    for(int i=head[u];i!=-1;i=g[i].nt)
    {
        if(!vis[i>>1])
        {
            vis[i>>1]=1;
            int v=g[i].to;
            if(!df[v])
            {
                tarjan(v);
                int tmp=dp[v][1];
                low[u]=min(low[u],low[v]);
                if(low[v]>df[u])bridge++,tmp++;
                if(tmp>dp[u][1])
                {
                    dp[u][0]=dp[u][1];
                    dp[u][1]=tmp;
                }
                else if(tmp>dp[u][0])dp[u][0]=tmp;
                ans=max(ans,dp[u][1]+dp[u][0]);
            }
            else low[u]=min(low[u],df[v]);
        }
    }
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)break;
        init(n);
        rep(i,1,m)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            addedg(x,y);
            addedg(y,x);
        }
        tarjan(1);
        printf("%d\n",bridge-ans);
    }
}