HDU-3749（点的双连通）

题目链接：

我是题

解题思路：

1、首先对于不连通的两个点用并查集预判
2、对于父节点相同的点找出他们是否在同一点的双连通分量中，要注意的是：即使在同一双连通分量中若该双连通分量只有两个点那答案也将只是1，否则才是2或者更多。
3、对于父节点相同但是不处于同一点双连通分量的点答案只有1

注意：这题数组越界会超时而不是re！！！

#include <iostream>
#include <stack>
#include <vector>
#include <string.h>
#include <map>
using namespace std;
const int maxn=5*1e3+5;
struct edge
{
    int from,to,next;
    edge(int a,int b,int c){from=a;to=b;next=c;}
    edge(int a,int b){from=a;to=b;}
    edge(){;}
}E[maxn*10];
int N,M,Q;stack<edge>ST;
int FA[maxn],DFN[maxn],low[maxn],is_cut[maxn],head[maxn*2],edgenum,dfs_time;
//bcc_cnt为点的双连通分量的数量,bcc_no为结点所位于的点的双连通分量，割点的bcc_no无意义
vector<int>bcc[maxn];int bcc_no[maxn],bcc_cnt;
vector<int>belong[maxn];//belong为结点可能会属于哪一个点的双连通分量，因为割点会属于多个点的双连通分量
void init()
{
    while(!ST.empty())ST.pop();
    dfs_time=edgenum=bcc_cnt=0;
    for(int i=0;i<N;i++){FA[i]=i;belong[i].clear();};
    memset(head,-1,sizeof(head));
    memset(DFN,0,sizeof(DFN));
    memset(low,0,sizeof(low));   
    memset(bcc_no,0,sizeof(bcc_no));
}
int fd(int x)
{
    if(FA[x]==x)return x;
    else return FA[x]=fd(FA[x]);
}
//链式前向星存图
void addedge(int u,int v)
{
    E[edgenum]=edge(u,v,head[u]);
    head[u]=edgenum++; 
}
//tarjian算法求点的双连通分量
void tarjian(int u,int fa)
{
    DFN[u]=low[u]=++dfs_time;
    for(int i=head[u];i!=-1;i=E[i].next)
    {
        int v=E[i].to;
        if(v==fa)continue;
        if(!DFN[v])
        {
            ST.push(edge(u,v));
            tarjian(v,u);
            low[u]=min(low[u],low[v]);
            if(low[v]>=DFN[u])
            {
                bcc[++bcc_cnt].clear();
                while(1)
                {
                    edge eg=ST.top();ST.pop();
                    if(bcc_no[eg.from]!=bcc_cnt)
                    {
                       bcc[bcc_cnt].push_back(eg.from);
                        belong[eg.from].push_back(bcc_cnt);
                        bcc_no[eg.from]=bcc_cnt;
                    }
                    if(bcc_no[eg.to]!=bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(eg.to);
                        belong[eg.to].push_back(bcc_cnt);
                        bcc_no[eg.to]=bcc_cnt;
                    }
                    if(eg.from==u&&eg.to==v)break;//当遍历到当前边是跳出
                }
            }
        }
        else if(DFN[v]<DFN[u])
        {
            ST.push(edge(u,v));
            low[u]=min(low[u],low[v]);
        }
    }
}
int main()
{
    int cnt=0;
    while(scanf("%d%d%d",&N,&M,&Q)==3&&(N+M+Q))
    {
        init();
        int u,v;
        for(int i=0;i<M;i++)
        {
            scanf("%d%d",&u,&v);
            addedge(u,v);
            addedge(v,u);
            int fu=fd(u),fv=fd(v);
            if(fu!=fv)FA[fu]=fv;
        }
        for(int i=0;i<N;i++)if(!DFN[i])tarjian(i,-1);
        printf("Case %d:\n",++cnt);
        while(Q--)
        {
            scanf("%d%d",&u,&v);
            if(fd(u)!=fd(v)){printf("zero\n");continue;}
            bool ok=false;int num;             
            int len1=belong[u].size(),len2=belong[v].size();
            for(int i=0;i<len1;i++)
            {
                 for(int j=0;j<len2;j++)if(belong[u][i]==belong[v][j]){num=belong[u][i];ok=true;break;}
            }
            if(ok&&bcc[num].size()>2)printf("two or more\n");
            else printf("one\n");
        }
    }
}
/*
3 1 2
0 1
0 2
1 0
4 4 2
0 1
0 2
1 2
2 3
1 2
1 3
0 0 0
*/