hdu3671 Boonie and Clyde (Tarjan求割点)

题目大意：给定连通无向图，求可行的点对的数量，该点对可以使图在删去该点对后剩下的图中，至少有一对点不连通。

Tarjan求强连通图的复杂度是O(n)，如果直接枚举两个点并且求连通的话，总的复杂度为O(n^3)

如果先删去一个点，如果剩下的图分成了二个以上的块，则认为只要删去了这个点，剩下n-1个点无论删去哪个都是有效答案。因此对答案贡献为n-1
如果分成了两个块，则要分情况讨论。如果有一块只有一个点，则删去这个点后，原来两个块又变成了一个块，此时这种情况对答案的贡献是n-2。如果两个块都只有一个点，则这个图在删点前就只有3个点，是无解的。

如果分成一个块，则按照正常的Tarjan求割点流程求割点数量即可。

因为每一对点都有重复统计一次，最后答案要除以2

Tarjan求割点流程：

在遍历树中，如果一个非根节点u的子节点v，有DFN[v]<=LOW[u]，证明该子节点不能通过一个回边回到节点u的上层。此时该节点u即为割点。
对于根节点，若它的子树数量>1，则它也是割点。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <set>
#include <map>
#include <vector>
using namespace std;
const int maxn = 1000005;
#define inf 0x3f3f3f3f
const int N = 10010;
struct Edge
{
    int to,next;
} edge[100010];
int n,m,fa[1010],x[10010],y[10010];
int tot,head[100010],num[1010];
int cut[10010];
int tim=0,low[N],dfn[N];;
int mp[1010][1010];
int cnt,ans;

void init()
{
    tot = 0;
    memset(num,0,sizeof(num));
    memset(head,-1,sizeof(head));
}
void add_edge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
int Find(int x)
{
    return x == fa[x]?x:fa[x] = Find(fa[x]);
}
void Union(int x,int y)
{
    int px = Find(x);
    int py = Find(y);
    if(px != py)
        fa[px] = py;
}
void Tarjan(int u,int root)
{
    dfn[u] = low[u] = tim++;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(dfn[v] == -1)
        {
            Tarjan(v,u);
            if(u == root)
                cnt++;
            else
            {
                low[u] = min(low[u],low[v]);
                if(low[v] >= dfn[u])
                    cut[u] = 1;
            }
        }
        else
            low[u] = min(low[u],dfn[v]);
    }
}
void solve(int x,int y,int z)
{
    for(int i = 1; i <= n; i++)
    {
        if(i == y || i == z || mp[x][i])
            continue;
        mp[x][i] = 1;
        mp[i][x] = 1;
        ans++;
    }
}
int main()
{
    int T,C = 1;
    //scanf("%d",&t);
    while(scanf("%d%d",&n,&m) && (n+m))
    {
        for(int i = 0; i < m; i++)
            scanf("%d%d",&x[i],&y[i]);
        if(n == 3)
        {
            printf("Case %d: 0\n",C++);
            continue;
        }
        ans = 0;
        memset(mp,0,sizeof(mp));
        for(int i = 1; i <= n; i++)
        {
            init();
            for(int j = 1; j <= n; j++)
            {
                fa[j] = j;
                num[j] = 0;
            }
            for(int j = 0; j < m; j++)
            {
                if(x[j] == i || y[j] == i)
                    continue;
                Union(x[j],y[j]);
                add_edge(x[j],y[j]);
                add_edge(y[j],x[j]);
            }
            cnt = 0;
            int mx = inf;
            for(int j = 1; j <= n; j++)
                if(j != i)
                    num[Find(j)]++;
            for(int j = 1; j <= n; j++)
                if(num[j])
                {
                    cnt++;
                    mx = min(mx,num[j]);
                }
            if(cnt > 2)
                solve(i,i,0);
            else if(cnt == 2)
            {
                if(mx == 1)
                {
                    int tmp;
                    for(int j = 1; j <= n; j++)
                        if(num[j] == 1)
                            tmp = j;
                    solve(i,i,tmp);
                }
                else
                    solve(i,i,0);
            }
            else
            {
                //printf("\n%d %d\n",i,ans);
                memset(dfn,-1,sizeof(dfn));
                memset(cut,0,sizeof(cut));
                memset(low,-1,sizeof(low));
                tim = 0;
                int root;
                for(int j = 1; j <= n; j++)
                    if(j != i)
                    {
                        root = j;
                        break;
                    }
                cnt = 0;
                Tarjan(root,root);
                for(int j = 1; j <= n; j++)
                {
                    if(j == i)
                        continue;
                    if(cut[j] && !mp[i][j])
                    {
                        mp[i][j] = 1;
                        mp[j][i] = 1;
                        ans++;
                    }
                }
                if(cnt > 1 && !mp[i][root])
                {
                    mp[i][root] = 1;
                    mp[root][i] = 1;
                    ans++;
                }
            }
        }
        printf("Case %d: %d\n",C++,ans);
    }
    return 0;
}