hdu4587 求割点变形

最新推荐文章于 2021-04-18 17:07:31 发布

原创最新推荐文章于 2021-04-18 17:07:31 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

图论同时被 2 个专栏收录

132 篇文章

订阅专栏

连通性

19 篇文章

订阅专栏

本文介绍了一道名为HDU 4587的问题，该问题要求找出在一个给定的无向图中，移除哪两个节点能够得到最多的连通分量。文章提供了一个详细的解决方案，通过枚举去除第一个节点，再利用求割点的方法来确定第二个节点，最终找到获得最大连通分量数的答案。

http://acm.hdu.edu.cn/showproblem.php?pid=4587

Problem Description

Suppose that G is an undirected graph, and the value of stab is defined as follows:

Among the expression,G _{-i, -j} is the remainder after removing node i, node j and all edges that are directly relevant to the previous two nodes. cntCompent is the number of connected components of X independently.
Thus, given a certain undirected graph G, you are supposed to calculating the value of stab.

Input

The input will contain the description of several graphs. For each graph, the description consist of an integer N for the number of nodes, an integer M for the number of edges, and M pairs of integers for edges (3<=N,M<=5000).
Please note that the endpoints of edge is marked in the range of [0,N-1], and input cases ends with EOF.

Output

For each graph in the input, you should output the value of stab.

Sample Input

Sample Output

/**
hdu4587 求割点变形
题目大意：给定一个图，去掉其中哪两点后能得到最多的连通块，是多少
解题思路：枚举去掉第一个点，然后利用求割点的模板就可以求出去掉另一点后的答案，取最多即可
*/
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;
const int maxn=5010;

struct note
{
    int v,next;
    bool cut;
} edge[maxn*2];

int head[maxn],ip;

void init()
{
    memset(head,-1,sizeof(head));
    ip=0;
}

int low[maxn],dfn[maxn],st[maxn],dex,top;
bool inst[maxn],cut[maxn];
int add_block[maxn];
int bridge;
int n,m,now;

void addedge(int u,int v)
{
    edge[ip].v=v,edge[ip].next=head[u],head[u]=ip++;
}

void tarjan(int u,int pre)
{
    low[u]=dfn[u]=++dex;
    st[top++]=u;
    inst[u]=true;
    int son=0;
    for(int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==pre)continue;
        if(v==now)continue;
        if(!dfn[v])
        {
            son++;
            tarjan(v,u);
            if(low[u]>low[v])low[u]=low[v];
            if(low[v]>dfn[u])
            {
                bridge++;
                edge[i].cut=true;
                edge[i^1].cut=true;
            }
            if(u!=pre&&low[v]>=dfn[u])
            {
                cut[u]=true;
                add_block[u]++;
            }
        }
        else if(low[u]>dfn[v])
        {
            low[u]=dfn[v];
        }
    }
    if(u==pre&&son>1)cut[u]=true;
    if(u==pre)add_block[u]=son-1;
    inst[u]=false;
    top--;
}

int solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(inst,false,sizeof(inst));
    memset(add_block,0,sizeof(add_block));
    memset(cut,false,sizeof(cut));
    dex=top=0;
    bridge=0;
    int cnt=0;
    for(int i=0;i<n;i++)
    {
        if(i!=now&&!dfn[i])
        {
            cnt++;
            tarjan(i,i);
        }
    }
    int ans=-1;
    for(int i=0;i<n;i++)
    {
        if(i!=now)
        {
           ans=max(ans,cnt+add_block[i]);
        }
    }
    return ans;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }
        int ans=-1;
        for(int i=0;i<n;i++)
        {
            now=i;
            ans=max(ans,solve());
        }
        printf("%d\n",ans);
    }
    return 0;
}