HDU 6184 Counting Stars 三元环计数

Counting Stars

题目意思：

给你一个图，问你有多少个子图是一个四边形加一个对角线。

思路：

枚举对角线，即枚举每一条边，如果存在两个不同的点，和这条边上的两点都相邻的话，这不就是我们所需要的图形吗？

直接开bitset，然后&一下，飞快的过了样例，交上去，飞快的MLE了。

那咋办啊？问大佬去了，大佬直接一句三元环傻逼题，就把我扔走了，，，w(ﾟДﾟ)w

留下了自己想。

发现那样的子图不就是共用一条边的三元环吗。

直接统计每条边参与了几个三元环，记作cnt[e]，那么答案就是

 

三元环计数有两种

一种是常数巨大的把点分为度数大于sqrt(m)和度数小于sqrt(m)的。

    对于度数大于sqrt(m)的u，放入一个集合中，枚举这个集合的三个点，判断是否相连。

        因为度数小于sqrt(m)的点至多有sqrt(m)个，可得时间复杂度O(sqrt(m)*sqrt(m)*sqrt(m))=O(m*sqrt(m))。

    对于度数小于sqrt(m)的u，单独计算，枚举这个点相邻的两个点x,y，判断是否相连。

        因为x,y也可以分为不同的点，所以需要在计数上注意一下。时间复杂度O(sqrt(m)*m)

 

因为上一种写起来过于麻烦（我懒）

所以给出另一种转为有向图的做法。

把每个边重定向，记录图中每个点的度数，对于每条边将它定向。对于一条边，将度数大的点指向度数小的点，如果度数相同就将编号小的点指向编号大的点。计数时枚举每个点，对于每个点x枚举它的出边，并将出边指向的点y打标记，对于所有出边指向的点y再枚举出边，如果这个出边指向的点z被打了标记，那么x,y,z就组成了一个三元环。

时间复杂度证明：

考虑时间复杂度分为两部分：一部分为每个点枚举出边，另一部分为每个出边指向的点枚举出边。

第一部分时间复杂度显然为O(n+m)，而第二部分我们分类讨论：

如果一个点的出度大于sqrt(m)，指向它的点出度一定要比它大，这样的点最多sqrt(m)个，时间复杂度为O(msqrt(m));

如果一个点的出度小于sqrt(m)，指向他的点最多有n个，时间复杂度为O(nsqrt(m))；

综上所述，时间复杂度为O(m*sqrt(m))。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+10;
struct  node{
    int u,to,ow;
}edge[maxn<<1];
pair<int,int> E[maxn<<1];
int head[maxn], tmp[maxn], du[maxn], vis[maxn], cnt, n, m;
long long E_cnt[maxn<<1];
char buf[1<<21],*p1=buf,*p2=buf;
inline char getc(){return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;}
bool read(int &x){
    register char ch;
    x=0;
    do{
        ch=getc();  if (ch==EOF)    return false;
    }while(!isdigit(ch));do{
        x=x*10+ch-'0';  ch=getc();  if (ch==EOF)    return false;
    }while(isdigit(ch));
    return true;
}

inline void add(int x, int y, int z){
    cnt++;  edge[cnt].u=y;  edge[cnt].to=head[x];   edge[cnt].ow=z; head[x]=cnt;
    return ;
}

int main(){
    while(read(n)&&read(m)){
        for (register int i=1;i<=n;++i){
            head[i]=du[i]=vis[i]=0;
        }
        for (register int i=1;i<=m;++i){
            read(E[i].first);   read(E[i].second);
            du[E[i].first]++;   du[E[i].second]++;
            E_cnt[i]=0;
        }
        cnt=0;
        for (register int i=1;i<=m;++i){
            if (du[E[i].first]>du[E[i].second]||(du[E[i].first]==du[E[i].second]&&E[i].first<E[i].second)){//重定向,度大的指向度小的
                add(E[i].first,E[i].second,i);
            }else{
                add(E[i].second,E[i].first,i);
            }
        }
        int v,w;
        for (register int u=1;u<=n;++u){
            for (register int i=head[u];i>0;i=edge[i].to){
                vis[edge[i].u]=u;   tmp[edge[i].u]=i;
            }
            for (register int i=head[u];i>0;i=edge[i].to){
                v=edge[i].u;
                for (register int j=head[v];j>0;j=edge[j].to){
                    if (vis[edge[j].u]==u){
                        E_cnt[i]++; E_cnt[j]++; E_cnt[tmp[edge[j].u]]++;
                    }
                }
            }
        }
        long long ans=0;
        for (register int i=1;i<=m;++i){
            ans+=E_cnt[i]*(E_cnt[i]-1)/2;
        }
        printf("%lld\n",ans);
    }
    return 0;
}