HDU

Little A is an astronomy lover, and he has found that the sky was so beautiful!
So he is counting stars now!
There are n stars in the sky, and little A has connected them by m non-directional edges.
It is guranteed that no edges connect one star with itself, and every two edges connect different pairs of stars.
Now little A wants to know that how many different "A-Structure"s are there in the sky, can you help him?
An "A-structure" can be seen as a non-directional subgraph G, with a set of four nodes V and a set of five edges E.
If V=(A,B,C,D) and E=(AB,BC,CD,DA,AC), we call G as an "A-structure".
It is defined that "A-structure" G1=V1+E1 and G2=V2+E2 are same only in the condition that V1=V2 and E1=E2

Input

    There are no more than 300 test cases.

    For each test case, there are 2 positive integers n and m in the first line.

    2≤n≤105, 1≤m≤min(2×105,n(n−1)2)
And then m lines follow, in each line there are two positive integers u and v, describing that this edge connects node u and node v.1≤u,v≤n,∑n≤3×105,∑m≤6×105

Output

    For each test case, just output one integer--the number of different "A-structure"s in one line.

Sample Input

    4 5
    1 2
    2 3
    3 4
    4 1
    1 3
    4 6
    1 2
    2 3
    3 4
    4 1
    1 3
    2 4

Sample Output

    1

    6

代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int MAXN = 1e5+10;

vector<int> G[MAXN];
set<LL> S;
bool vis[MAXN];
int pre[MAXN],Du[MAXN];

inline void init(){
	for(int i=1 ; i<MAXN ; ++i)G[i].clear();
	S.clear();
	memset(vis,false,sizeof vis);
	memset(Du,0,sizeof Du);
	memset(pre,0,sizeof pre);
}

int main(){
	
	int N,M;
	while(scanf("%d %d",&N,&M)!=EOF){
		init();
		int Flag = sqrt(1.0*M);
		for(int i=1 ; i<=M ; ++i){
			int a,b;
			scanf("%d %d",&a,&b);
			G[a].push_back(b);
			G[b].push_back(a);
			S.insert((LL)a*N+b);
			S.insert((LL)b*N+a);
			Du[a]++;Du[b]++;
		}
		LL re = 0;
		for(int i=1 ; i<=N ; ++i){
			vis[i] = true;
			for(int j=0 ; j<G[i].size() ; ++j)pre[G[i][j]] = i;
			for(int j=0 ; j<G[i].size() ; ++j){
				LL sum = 0;
				int t = G[i][j];
				if(vis[t])continue;
				if(Du[t]<=Flag){
					for(int k=0 ; k<G[t].size() ; ++k){
						if(pre[G[t][k]] == i)++sum;
					}
				}
				else {
					for(int k=0 ; k<G[i].size() ; ++k){
						if(S.find((LL)G[i][k]*N+t) != S.end())++sum;
					}
				}
				re += (LL)(sum*(sum-1)/2);
			}
		}
		printf("%lld
",re);
	}
	
	return 0;
}