三元环HDU 6184

HDU - 6184 C - Counting Stars

　　题目大意：有n个点，m条边，问有一共有多少个‘structure’也就是满足V=(A,B,C,D) and E=(AB,BC,CD,DA,AC)这样一个图形，类似于四边形中间连接了一条对角线。

　　如果我们把这个四边形拆分的话，其实就是两个共用一条边的三角形，而在图中就是三元环。求三元环有两种求法，个人感觉这个三元环的时间复杂度很玄学。

　　第一种一种就是枚举点x，然后枚举和点x相连的y，这时根据y的度，如果y的度小于等于sqrt(m)，那么我们可以直接枚举和y相连的z，看z和x是否相连，这时时间复杂度最差是m*sqrt(m)，如果y的度大于sqrt(m)的话，说明y有很多点相连，再枚举y的话就会超时，这时枚举再枚举x找z，根据set或者map来判断y和z是否相连，复杂度最差也是m*sqrt(m)，详情见代码

 #include<cstdio>
 #include<vector>
 #include<set>
 #include<cstring>
 using namespace std;
 typedef long long ll;
 const int N=;
 set<ll> s;
 vector<int> vv[N];
 int link[N],book[N];
 inline void init(int n)
 {
     s.clear();
     for(int i=;i<=n;i++)
     {
         vv[i].clear();
         link[i]=;
         book[i]=;
     }
 }
 int main()
 {
     int n,m,u,v;
     while(~scanf("%d%d",&n,&m))
     {
         init(n);
         for(int i=;i<m;i++)
         {
             scanf("%d%d",&u,&v);
             vv[u].push_back(v);
             vv[v].push_back(u);
             s.insert(1ll*u*(n+)+v);//set保存u和v相连的信息
             s.insert(1ll*v*(n+)+u);
         }
         ll ans=;
         for(int x=;x<=n;x++)
         {
             book[x]=;//每个点只有枚举一遍
             for(int i=;i<vv[x].size();i++)
                 link[vv[x][i]]=x;//记录和x点相连的点
             //枚举和x相连的y
             for(int i=;i<vv[x].size();i++)
             {
                 int y=vv[x][i],sum=;
                 if(book[y])
                     continue;
                 if(1ll*vv[y].size()*vv[y].size()<=m)
                 {
                     //枚举找到和x相连的z
                     for(int j=;j<vv[y].size();j++)
                         if(link[vv[y][j]]==x)
                             sum++;
                 }
                 else
                 {
                     //枚举找到和y相连的z
                     for(int j=;j<vv[x].size();j++)
                         if(s.find(1ll*y*(n+)+vv[x][j])!=s.end())
                             sum++;
                 }
                 ans+=1ll*sum*(sum-)/;//每两个三元环就可以组成一个需要的图形
             }
         }
         printf("%lld\n",ans);
     }
     return ;
 }

暴力m*sqrt(m)

　　当然上面那个做法有点类似于暴力，而且前向星建图会超时，不知道为啥子，所以我们还需要第二种方法

　　第二种是枚举边，不过得先对边进行处理。也就是统计每个点的度，然后我们根据这个度把之前的双向边变成度数大的点指向度数小的点，度数相同按序号的有向边，这样构成了一个有向无环图。这样我们枚举每条边，统计这条边能构成几个三元环，最后统计答案。但时间复杂度我不懂算，很玄学，比第一种快了不只一倍，并且在建边时用swap会超时。。

 #include<cstdio>
 #include<algorithm>
 #include<vector>
 using namespace std;
 typedef long long ll;
 typedef pair<int,int> pii;
 const int N=;
 vector<pii> vv[N];
 int link[N],line[N],du[N],val[*N],u[*N],v[*N];
 inline void init(int n)
 {
     for(int i=;i<=n;i++)
     {
         du[i]=;
         vv[i].clear();
         link[i]=line[i]=;
     }
 }
 int main()
 {
     int n,m;
     while(~scanf("%d%d",&n,&m))
     {
         init(n);
         for(int i=;i<=m;i++)
         {
             val[i]=;
             scanf("%d%d",&u[i],&v[i]);
             du[u[i]]++,du[v[i]]++;
         }
         for(int i=;i<=m;i++)//按度数改成有向边
         {//每条边记录下另一个端点和边的编号
             if(du[u[i]]<du[v[i]])
                 vv[u[i]].push_back(pii(v[i],i));
             else if(du[u[i]]>du[v[i]])
                 vv[v[i]].push_back(pii(u[i],i));
             else
             {
                 if(u[i]<v[i])
                     vv[u[i]].push_back(pii(v[i],i));
                 else
                     vv[v[i]].push_back(pii(u[i],i));
             }
         //    改成swap(u[i],v[i])，然后再建边会超时
         }
         for(int i=;i<=m;i++)//枚举每条边
         {
             int x=u[i],y=v[i];
             for(int j=;j<vv[x].size();j++)
             {//遍历和x相连的z
                 int z=vv[x][j].first,id=vv[x][j].second;
                 link[z]=x;//z和x相连
                 line[z]=id;//记录相连的这条边的编号
             }
             for(int j=;j<vv[y].size();j++)
             {//遍历和y相连的z
                 int z=vv[y][j].first,id=vv[y][j].second;
                 if(link[z]==x)
                 {//如果这个z和x相连的话
                     val[i]++;
                     val[id]++;
                     val[line[z]]++;
                     //相关的三条边都可以组成了一个三元环
                 }
             }
         }
         ll ans=;
         for(int i=;i<=m;i++)
             ans+=1ll*val[i]*(val[i]-)/;
         printf("%lld\n",ans);
     }
     return ;
 }

vector建图

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 typedef long long ll;
 const int N=;
 struct Side{
     int v,ne;
 }S[*N];
 int sn,head[N],link[N],line[N],du[N],val[*N],u[*N],v[*N];
 inline void init(int n)
 {
     sn=;
     for(int i=;i<=n;i++)
     {
         head[i]=-;
         du[i]=;
         link[i]=;
         line[i]=-;
     }
 }
 inline void add(int u,int v)
 {
     S[sn].v=v;
     S[sn].ne=head[u];
     head[u]=sn++;
 }
 int main()
 {
     int n,m;
     while(~scanf("%d%d",&n,&m))
     {
         init(n);
         for(int i=;i<m;i++)
         {
             val[i]=;
             scanf("%d%d",&u[i],&v[i]);
             du[u[i]]++,du[v[i]]++;
         }
         for(int i=;i<m;i++)
         {
             if(du[u[i]]<du[v[i]])
                 add(u[i],v[i]);
             else if(du[u[i]]>du[v[i]])
                 add(v[i],u[i]);
             else
             {
                 if(u[i]<v[i])
                     add(u[i],v[i]);
                 else
                     add(v[i],u[i]);
             }
         }
         for(int i=;i<m;i++)
         {
             int x=u[i],y=v[i];
             for(int j=head[x];j!=-;j=S[j].ne)
             {
                 link[S[j].v]=x;
                 line[S[j].v]=j;
             }
             for(int j=head[y];j!=-;j=S[j].ne)
             {
                 int z=S[j].v;
                 if(link[z]==x)
                 {
                     val[i]++;
                     val[j]++;
                     val[line[z]]++;
                 }
             }
         }
         ll ans=;
         for(int i=;i<m;i++)
             ans+=1ll*val[i]*(val[i]-)/;
         printf("%lld\n",ans);
     }
     return ;
 }

前向星建图