Problem:
Score : 1700 points

Problem Statement

We have a grid with N rows and N columns.
The cell at the i-th row and j-th column is denoted (i, j).

Initially, M of the cells are painted black, and all other cells are white.
Specifically, the cells (a_1, b_1), (a_2, b_2), ..., (a_M, b_M) are painted black.

Snuke will try to paint as many white cells black as possible, according to the following rule:

If two cells (x, y) and (y, z) are both black and a cell (z, x) is white for integers 1≤x,y,z≤N, paint the cell (z, x) black.

Find the number of black cells when no more white cells can be painted black.

Constraints

1≤N≤10^5

1≤M≤10^5

1≤a_i,b_i≤N

All pairs (a_i, b_i) are distinct.

Input

The input is given from Standard Input in the following format:

N M
a_1 b_1
a_2 b_2
:
a_M b_M

Output

Print the number of black cells when no more white cells can be painted black.

Sample Input 1

3 2
1 2
2 3

Sample Output 1

3

It is possible to paint one white cell black, as follows:

Since cells (1, 2) and (2, 3) are both black and a cell (3, 1) is white, paint the cell (3, 1) black.

Sample Input 2

2 2
1 1
1 2

Sample Output 2

4

It is possible to paint two white cells black, as follows:

Since cells (1, 1) and (1, 2) are both black and a cell (2, 1) is white, paint the cell (2, 1) black.

Since cells (2, 1) and (1, 2) are both black and a cell (2, 2) is white, paint the cell (2, 2) black.

Sample Input 3

4 3
1 2
1 3
4 4

Sample Output 3

3

No white cells can be painted black.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)



#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;

#define fir first
#define sec second

typedef long long LL;
typedef pair<int, int> PP;

namespace INPUT {
	const int L = 1 << 15;
	char _buf[L], *S, *T, c;
	char _gc () {
		if (S == T) {
			T = (S = _buf) + fread(_buf, 1, L, stdin);
			if (S == T) return EOF;
		}
		return *S++;
	}
	void readi (int &X) {
		for (c = _gc (); c < '0' || c > '9'; c = _gc ()); X = c & 15;
		for (c = _gc (); c >= '0' && c <= '9'; X = X * 10 + (c & 15), c = _gc ());
	}
}
using INPUT :: readi;

const int Maxn = 1E5 + 5;

int N, M;
struct E {
	int v, nxt;
} adj[Maxn << 1];
int hed[Maxn], TE;

bool vis[Maxn], FLAG;
int col[Maxn], Num[5];

LL Ans;

int nextcol (int c, int k) {
return (3 + c + ((k & 1) ? 1 : (-1)) - 1) % 3 + 1;}

void addedge (int u, int v) {
adj[++TE].v = v, adj[TE].nxt = hed[u], hed[u] = TE;}

void Dfs (int u, int Col) {
	++Num[Col], col[u] = Col, vis[u] = true;
	for (int k = hed[u]; ~k; k = adj[k].nxt)
		if (!vis[adj[k].v]) Dfs (adj[k].v, nextcol (Col, k));
		else if (nextcol (Col, k) != col[adj[k].v]) FLAG = false;
}

int main () {
	readi (N), readi (M);
	memset (hed, -1, sizeof (hed));
	for (int u, v, i = 1; i <= M; ++i)
		readi (u), readi (v),
		addedge (u, v), addedge (v, u);
	memset (vis, false, sizeof (vis));
	for (int i = 1; i <= N; ++i)
	if (!vis[i]) {
		Num[1] = Num[2] = Num[3] = 0, FLAG = true, Dfs (i, 1);
		if (Num[2] == 0 || Num[3] == 0) {Ans += Num[1] + Num[2] + Num[3] - 1; continue ;}
		if (!FLAG) Ans += (LL)(Num[1] + Num[2] + Num[3]) * (Num[1] + Num[2] + Num[3]);
		else Ans += (LL)Num[1] * Num[2] + (LL)Num[2] * Num[3] + (LL)Num[3] * Num[1];
	}
	printf ("%lld", Ans);
	return 0;
}