Rikka with Graph(hdu5631)

Rikka with Graph

 

 Accepts: 123

 

 Submissions: 525

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 65536/65536 K (Java/Others)

问题描述

众所周知，萌萌哒六花不擅长数学，所以勇太给了她一些数学问题做练习，其中有一道是这样的：

给出一张 nn 个点 n+1n+1 条边的无向图，你可以选择一些边（至少一条）删除。

现在勇太想知道有多少种方案使得删除之后图依然联通。

当然，这个问题对于萌萌哒六花来说实在是太难了，你可以帮帮她吗？

输入描述

第一行一个整数表示数据组数 T(T leq 30)T(T≤30)。

每组数据的第一行是一个整数 n(n leq 100)n(n≤100)。

接下来 n+1n+1 行每行两个整数 u,vu,v 表示图中的一条边。

输出描述

对每组数据输出一行一个整数表示答案。

输入样例

1
3
1 2
2 3
3 1
1 3

输出样例

9
思路：并查集，最短路，组合，先用并查集，找一到n-1条可以连通所有点的边，同时也判断了，整个图是否连通，然后剩下的2条边，分别以该边的一个点为起点
另一个位终点，用最短路搜连接这两个点的最小环由哪些边组成，然后记录个环的共同边ans，和两个环各自的边nk,mk,最后答案就是nk+mk-ans+nk*mk-ans*ans;nk+mk-ans--去掉一个边的方案，应为环去一边，所有点还是连通的。

nk*mk-ans*ans--去两个边的可能每个环出一个边方案为nk*mk，因为两个环重合的地方不能去，所以减ans*ans；
这个复杂度为（N*N）AC 0ms

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<math.h>
using namespace std;
struct node
{
    int x;
    int y;
};
vector<int>dian[110];
node bian[110];
bool flag[110];
int bin[110];
int shen[110];
int dj[110];
int TWO[200];
int HH[110];
int mapp[110][110];
int ma[110][110];
int pre[110];
int DD[110];
int CC[110];
map<int,int>my;
int cha(int x,int y);
void dfs(int n,int z);
void ME()
{ int i,j;
    memset(flag,0,sizeof(flag));
    for(i=0; i<110; i++)
    {
        bin[i]=i;
        shen[i]=1;
    }
    for(i=0; i<110; i++)
    {
        for(j=0; j<110; j++)
        {
            mapp[i][j]=200;
        }
    }
} void dis(int n,int k);
int main(void)
{
    int i,j,k,p,q,n;
    //freopen("data.in","r",stdin);
    //freopen("wrong.out","w",stdout);
    scanf("%d",&k);
    while(k--)
    {
        ME();scanf("%d",&n);
        int cnt=0;
        for(i=0; i<=n; i++)
        {
            scanf("%d %d",&bian[i].x,&bian[i].y);
            int s=cha(bian[i].x,bian[i].y);
            if(s==1)
            {
                TWO[cnt++]=i;
            }
        }
        for(i=1; i<=n; i++)
        {
            for(j=i; bin[j]!=j;)
                j=bin[j];
            HH[i]=j;
        }
        for(i=2; i<=n; i++)
        {
            if(HH[i]!=HH[1])
            {
                break;
            }
        }
        if(i!=n+1)
        {
            printf("0
");
        }
        else
        {
            int vx=bian[TWO[0]].x;
            int vy=bian[TWO[0]].y;
            int vxx=bian[TWO[1]].x;
            int vyy=bian[TWO[1]].y;
            for(i=0; i<=n; i++)
            {
                if(i!=TWO[0]&&i!=TWO[1])
                {
                    mapp[bian[i].x][bian[i].y]=1;
                    mapp[bian[i].y][bian[i].x]=1;
                    ma[bian[i].x][bian[i].y]=i;
                    ma[bian[i].y][bian[i].x]=i;
                }
            }
                dis(vxx,n);
                int va=pre[vyy];int hh=vyy;
                memset(DD,0,sizeof(DD));
                while(va!=-1)
                {
                    DD[va]=1;
                    int xx=bian[va].x;
                    int yy=bian[va].y;
                    if(hh!=xx)
                    {va=pre[xx];hh=xx;}
                    else {va=pre[yy];hh=yy;}

                }
            DD[TWO[1]]=1;
                 dis(vx,n);
                 va=pre[vy];hh=vy;
                memset(CC,0,sizeof(CC));
               while(va!=-1)
                {
                    CC[va]=1;
                    int xx=bian[va].x;
                    int yy=bian[va].y;
                    if(hh!=xx)
                    {va=pre[xx];hh=xx;}
                    else {va=pre[yy];hh=yy;}

                }
            CC[TWO[0]]=1;
            int ans=0;int nk=0;int mk=0;
            for(i=0;i<=n;i++)
            {
                if(CC[i]&&DD[i])
                {
                    ans++;
                }
                if(CC[i])
                {
                    nk++;
                }
                if(DD[i])
                {
                    mk++;
                }
            }
            int sum=nk+mk-ans+nk*mk-ans*ans;
            printf("%d
",sum);
        }}return 0;    }
   int cha(int x,int y)
    {
        int i,j;
        int xx,yy;
        for(xx=x; bin[xx]!=xx;)
            xx=bin[xx];
        for(yy=y; bin[yy]!=yy;)
            yy=bin[yy];
        if(xx==yy)
        {
            return 1;
        }
        if(xx!=yy)
        {
            if(shen[xx]>shen[yy])
            {
                shen[xx]+=shen[yy];
                bin[yy]=xx;
            }
            else
            {
                shen[yy]+=shen[xx];
                bin[xx]=yy;
            }
        }
        return 0;
    }
    void dis(int n,int k)
    {
        fill(dj,dj+110,1000);
        fill(pre,pre+110,-1);
        dj[n]=0;int i,j;
        memset(flag,0,sizeof(flag));
        pre[n]=-1;
        while(true)
        {
            int l=-1;
            for(i=1; i<=k; i++)
            {
                if((l==-1||(dj[l]>dj[i]))&&!flag[i])
                {
                    l=i;
                }
            }
            if(l==-1)
            {
                break;
            }
            flag[l]=true;
            for(i=1; i<=k; i++)
            {
                if(mapp[l][i]+dj[l]<dj[i])
                {
                    pre[i]=ma[l][i];
                    dj[i]=mapp[l][i]+dj[l];
                }
            }
        }
    }

思路2：让 nn 个点联通最少需要 n-1n−1 条边，所以最多只能删除两条边，我们可以枚举删除的这两条边（或者唯一的一条边），然后并查集判断连通性就好了。时间复杂度 O(n^3)。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<stack>
#include<iomanip>
#include<cstdio>
#include<map>
#include<set>
#include <cmath>
#include <ctime>
#include <cstring>
#include <cctype>
#include <cassert>
#include<vector>
using namespace std;
struct node
{
    int x;
    int y;
};
node dian[200];
vector<int>vec[102];
bool flag[102];
bool flag1[103];
bool flag2[103];
int bincha[102];
int shendu[102];
int huanyuan[102];
int an=0;
void me()
{
    memset(flag1,0,sizeof(flag));
    memset(flag2,0,sizeof(flag1));
    memset(flag,0,sizeof(flag));
    int i,j;
    for(i=0; i<102; i++)
    {
        bincha[i]=i;
        shendu[i]=1;
    }
}
void BB(int a,int b)
{
    int x,y;
    for(x=a; bincha[x]!=x;)
    {
        x=bincha[x];
    }
    for(y=b; bincha[y]!=y;)
    {
        y=bincha[y];
    }
    if(x!=y)
    {
        if(shendu[x]>shendu[y])
        {
            shendu[x]+=shendu[y];
            bincha[y]=x;
        }
        else
        {
            shendu[y]+=shendu[x];
            bincha[x]=y;
        }
    }
}
void slove (int s)
{
    int i,j,k,m,n;
    int fl=0;int nn,mm;
    for(i=0; i<=s; i++)
    {
        for(j=i+1; j<=s; j++)
        {
            for(int z=0; z<102; z++)
            {
                bincha[z]=z;
                shendu[z]=1;
            }
            for(m=0; m<=s; m++)
            {
                if(m!=i&&m!=j)
                {
                    BB(dian[m].x,dian[m].y);
                }
            }
            for(m=1;m<=s; m++)
            {
                for(n=m; bincha[n]!=n;)
                    n=bincha[n];
                huanyuan[m]=n;
            }
            for(n=2; n<=s; n++)
            {
                if(huanyuan[n]!=huanyuan[1])
                {
                    break;
                }
            }
            if(n==s+1)
            {
                an++;
                flag[i]=true;
                flag[j]=true;

            }
        }
        if(fl)
            break;
    }int ans[102];int cnt=0;
    int bns[102];int cnt1=0;

}
int main(void)
{
    int i,j,k,p,q;
    int N;  //freopen("data.in","r",stdin);
    //freopen("wrong.out","w",stdout);
    cin>>k;
    while(k--)
    {  scanf("%d",&N) ;an=0;
        for(i=0; i<102; i++)
            vec[i].clear();
        me();

        for(i=0; i<N+1; i++)
        {
            cin>>p>>q;
            dian[i].x=p;
            dian[i].y=q;
            vec[p].push_back(q);
            vec[q].push_back(p);
            BB(p,q);
        }
        for(i=1;i<=N;i++)
        {
            for(j=i;bincha[j]!=j;)
                j=bincha[j];
            huanyuan[i]=j;
        }
        for(i=2;i<=N;i++)
        {
            if(huanyuan[i]!=huanyuan[1])
            {
                break;
            }
        }
        if(i!=N+1)
        {
            printf("0
");
        }
        else
        {
            slove(N);
            for(i=0;i<=N;i++)
            {
                if(flag[i])
                {
                    an++;
                }
            }
            printf("%d
",an);
        }

    }
    return 0;
}