Problem:
Score : 600 points

Problem Statement

There are N dots in a two-dimensional plane. The coordinates of the i-th dot are (x_i, y_i).

We will repeat the following operation as long as possible:

Choose four integers a, b, c, d (a \neq c, b \neq d) such that there are dots at exactly three of the positions (a, b), (a, d), (c, b) and (c, d), and add a dot at the remaining position.

We can prove that we can only do this operation a finite number of times. Find the maximum number of times we can do the operation.

Constraints

1 \leq N \leq 10^5

1 \leq x_i, y_i \leq 10^5

If i \neq j, x_i \neq x_j or y_i \neq y_j.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
:
x_N y_N

Output

Print the maximum number of times we can do the operation.

Sample Input 1

3
1 1
5 1
5 5

Sample Output 1

1

By choosing a = 1, b = 1, c = 5, d = 5, we can add a dot at (1, 5). We cannot do the operation any more, so the maximum number of operations is 1.

Sample Input 2

2
10 10
20 20

Sample Output 2

0

There are only two dots, so we cannot do the operation at all.

Sample Input 3

9
1 1
2 1
3 1
4 1
5 1
1 2
1 3
1 4
1 5

Sample Output 3

16

We can do the operation for all choices of the form a = 1, b = 1, c = i, d = j (2 \leq i,j \leq 5), and no more. Thus, the maximum number of operations is 16.

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		int N = int.Parse(Console.ReadLine());
		int[,]A = new int[N,2];
		var uf = new UnionFind(100001);
		var list = new List<int>[100001];
		for(var i=0;i<100001;i++){
			list[i] = new List<int>();
		}
		for(var i=0;i<N;i++){
			string[] str = Console.ReadLine().Split();
			A[i,0] = int.Parse(str[0]);
			A[i,1] = int.Parse(str[1]);
			list[A[i,0]-1].Add(A[i,1]-1);
		}
		var dic = new Dictionary<int,long>();
		for(var i=0;i<100001;i++){
			dic[i] = 1;
		}
		for(var i=0;i<100001;i++){
			if(list[i].Count >= 2){
				for(var j=1;j<list[i].Count;j++){
					if(!uf.IsSameGroup(list[i][0],list[i][j])){
						long a = dic[uf.Root(list[i][0])];
						uf.Unite(list[i][0],list[i][j]);
						dic[uf.Root(list[i][0])] = a+1;
					}
				}
			}
		}
		long ans = 0;
		for(var i=0;i<100001;i++){
          	if(list[i].Count>=1){
			int[]C = new int[100001];
			int[]D = new int[100001];
			for(var j=0;j<list[i].Count;j++){
				D[uf.Root(list[i][j])]++;
			}
			for(var j=0;j<list[i].Count;j++){
				if(C[uf.Root(list[i][j])]==0){
					ans += dic[uf.Root(list[i][j])] - D[uf.Root(list[i][j])];
					C[uf.Root(list[i][j])] = 1;
				}
			}
            }
		}
		Console.WriteLine(ans);
	}
	
	public class UnionFind
{
    private int[] data;
	public UnionFind(int size){
        data = new int[size];
        for (int i = 0; i < size; i++) data[i] = -1;
    }
    public bool Unite(int x, int y){
        x = Root(x);
        y = Root(y);
        if (x != y){
            if (data[y] < data[x]){
                var tmp = y;
                y = x;
                x = tmp;
            }
            data[x] += data[y];
            data[y] = x;
        }
        return x != y;
    }
	public bool IsSameGroup(int x, int y){
        return Root(x) == Root(y);
    }
    public int Root(int x){
        return data[x] < 0 ? x : data[x] = Root(data[x]);
    }
}

}