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;
using System.Linq;
using System.Text;

using System.Runtime.CompilerServices;

public class Contest
{
	static void Swap<T>(ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; }
	public const long MOD1 = 1000000007L; // 10^9+7

	public static void Main() {
        int n;
		VT<int,int>[] xyl;
		MyIO.ReadMulti(out n);
		MyIO.ReadLines(n, out xyl);

/*
		Dictionary<int,HashSet<int>> dicx = new Dictionary<int, HashSet<int>>();
		Dictionary<int,HashSet<int>> dicy = new Dictionary<int, HashSet<int>>();
		foreach(var e in xyl){
			if(!dicx.ContainsKey(e.Item1)) dicx[e.Item1] = new HashSet<int>();
			dicx[e.Item1].Add(e.Item2);
			if(!dicy.ContainsKey(e.Item2)) dicy[e.Item2] = new HashSet<int>();
			dicy[e.Item2].Add(e.Item1);
		}
		int cnt = 0;
		bool update=false;
		List<VT<int,int>> nl = new List<VT<int, int>>();
		foreach(var e in xyl){
			foreach(var x in dicy[e.Item2])
			foreach(var y in dicx[e.Item1])
			if((x!=e.Item1)&&(y!=e.Item2)&&(!dicx[x].Contains(y)))
			{
				nl.Add(new VT<int, int>(x,y));
				dicx[x].Add(y);
				dicy[y].Add(x);
				cnt++;
				update = true;
			}
		}

		while(update){
			update = false;
			List<VT<int,int>> tl = new List<VT<int, int>>();
			foreach(var e in nl){
				foreach(var x in dicy[e.Item2])
				foreach(var y in dicx[e.Item1])
				if((x!=e.Item1)&&(y!=e.Item2)&&(!dicx[x].Contains(y)))
				{
					tl.Add(new VT<int, int>(x,y));
					dicx[x].Add(y);
					dicy[y].Add(x);
					cnt++;
					update = true;
				}
			}
			nl = tl;
		}

*/


		Dictionary<int,HashSet<int>> dicx = new Dictionary<int, HashSet<int>>();
		Dictionary<int,HashSet<int>> dicy = new Dictionary<int, HashSet<int>>();
		for(int i=0;i<n;i++){
			var e = xyl[i];
			if(!dicx.ContainsKey(e.Item1)) dicx[e.Item1] = new HashSet<int>();
			dicx[e.Item1].Add(i);
			if(!dicy.ContainsKey(e.Item2)) dicy[e.Item2] = new HashSet<int>();
			dicy[e.Item2].Add(i);
		}

		List<List<int>> grp = new List<List<int>>();
		bool[] used = new bool[n];
		Func<int,bool> f = null;
		f = (i)=>{
			if(used[i]) return false;
			used[i] = true;
			grp[grp.Count-1].Add(i);
			foreach(var j in dicy[xyl[i].Item2])  f(j);
			foreach(var j in dicx[xyl[i].Item1])  f(j);
			return true;
		};
		for(int i=0;i<n;i++){
			if(!used[i]){
				grp.Add(new List<int>());
				f(i);
			}
		}

		int cnt = 0;
		foreach(var g in grp){
			if(2<g.Count){
				HashSet<int> cx = new HashSet<int>();
				HashSet<int> cy = new HashSet<int>();
				foreach(var i in g){
					if(!cx.Contains(xyl[i].Item1)) cx.Add(xyl[i].Item1);
					if(!cy.Contains(xyl[i].Item2)) cy.Add(xyl[i].Item2);
				}
				cnt += cx.Count*cy.Count-g.Count;
			}
		}


		MyIO.WriteMulti(cnt);
 
 
 
		
	}

 

 
 
 
}
 






public struct VT<T, U>
{
	public T Item1; public U Item2;
    public VT(T a, U b) { Item1 = a; Item2 = b; }
}
public struct VT<T, U, V>
{
	public T Item1; public U Item2; public V Item3;
    public VT(T a, U b, V c) { Item1 = a; Item2 = b; Item3 = c; }
}
public struct VT<T, U, V, W>
{
	public T Item1; public U Item2; public V Item3; public W Item4;
    public VT(T a, U b, V c, W d) { Item1 = a; Item2 = b; Item3 = c; Item4 = d; }
}

public class Printer : System.IO.StreamWriter
{
	public override IFormatProvider FormatProvider { get { return System.Globalization.CultureInfo.InvariantCulture; } }
	public Printer(System.IO.Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	public Printer(System.IO.Stream stream, Encoding encoding) : base(stream, encoding) { }
}
public static class MyIO
{
	private static char[] splitter = new char[] {' '};
	private static bool eq<T, U>() => typeof(T).Equals(typeof(U));
	private static T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
	private static T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
	                                  : eq<T, long>()   ? ct<T, long>(long.Parse(s))
	                                  : eq<T, double>() ? ct<T, double>(double.Parse(s, System.Globalization.CultureInfo.InvariantCulture))
	                                  : eq<T, char>()   ? ct<T, char>(s[0])
	                                                    : ct<T, string>(s);				
	public static string[] ReadMulti<T>(out T a) {
		var ar = Console.ReadLine().Split(splitter, StringSplitOptions.RemoveEmptyEntries); 
		a = cv<T>(ar[0]);
		return ar;
	}
	public static string[] ReadMulti<T, U>(out T a, out U b) {
		var ar = ReadMulti<T>(out a); 
        b = cv<U>(ar[1]);
		return ar;
	}
	public static string[] ReadMulti<T, U, V>(out T a, out U b, out V c) {
		var ar = ReadMulti<T, U>(out a, out b); 
        c = cv<V>(ar[2]);
		return ar;
	}
	public static string[] ReadMulti<T, U, V, W>(out T a, out U b, out V c, out W d) {
		var ar = ReadMulti<T, U, V>(out a, out b, out c); 
        d = cv<W>(ar[3]);
		return ar;
	}
	public static string[] ReadMulti<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
		var ar = ReadMulti<T, U, V, W>(out a, out b, out c, out d); 
        e = cv<X>(ar[4]);
		return ar;
	}
	public static string[] ReadMulti<T, U, V, W, X, Y>(out T a, out U b, out V c, out W d, out X e, out Y f) {
		var ar = ReadMulti<T, U, V, W, X>(out a, out b, out c, out d, out e); 
        f = cv<Y>(ar[5]);
		return ar;
	}
	public static string[] ReadArray<T>(out T[] a) {		
		var ar = Console.ReadLine().Split(splitter, StringSplitOptions.RemoveEmptyEntries);
		a = ar.Select(cv<T>).ToArray();
		return ar;
	}		
	public static string[][] ReadLines<T>(int n, out T[] a) {
		a = new T[n];
		string[][] arr = new string[n][];
		for(int i=0; i<n; i++) arr[i] = ReadMulti(out a[i]);
		return arr;
	}
	public static string[][] ReadLines<T, U>(int n, out VT<T, U>[] a) {
		a = new VT<T, U>[n];
		string[][] arr = new string[n][];
		for(int i=0; i<n; i++) {
			T o; U p;
			arr[i] = ReadMulti(out o, out p);
			a[i] = new VT<T, U>(o, p);
		}
		return arr;
	}
	public static string[][] ReadLines<T, U, V>(int n, out VT<T, U, V>[] a) {
		a = new VT<T, U, V>[n];
		string[][] arr = new string[n][];
		for(int i=0; i<n; i++) {
			T o; U p; V q;
			arr[i] = ReadMulti(out o, out p, out q);
			a[i] = new VT<T, U, V>(o, p, q);
		}
		return arr;
	}
	public static string[][] ReadLines<T, U, V, W>(int n, out VT<T, U, V, W>[] a) {
		a = new VT<T, U, V, W>[n];
		string[][] arr = new string[n][];
		for(int i=0; i<n; i++) {
			T o; U p; V q; W r;
			arr[i] = ReadMulti(out o, out p, out q, out r);
			a[i] = new VT<T, U, V, W>(o, p, q, r);
		}
		return arr;
	}
	public static string[][] ReadMatrix<T>(int n, out T[][] a) {
		a = new T[n][];
		string[][] arr = new string[n][];
		for(int i=0; i<n; i++) arr[i] = ReadArray(out a[i]);
		return arr;
	}

	private static void wwp(Action act){
		var sw = new Printer(Console.OpenStandardOutput()){AutoFlush = false};
		Console.SetOut(sw);
		act();
		Console.Out.Flush();
		sw.AutoFlush = true;
		Console.SetOut(sw);
	}
	private static string wfm(Type t){
		return t.Equals(typeof(double)) ? "{0:F10}" : "{0}";
	}
	public static void WriteMulti(params object[] a) {
		wwp(()=>{
			for(int i=0;i<a.Length;i++) {
				string fs = wfm(a[i].GetType()) + ((i<a.Length-1) ? " " : Environment.NewLine);
				Console.Write(fs, a[i]);
			}
		});
	}
	public static void WriteArray<T>(T[] a) {
		wwp(()=>{
			string fs = wfm(typeof(T));
			string fs1 = fs + " ";
			string fs2 = fs + Environment.NewLine;
			for(int i=0;i<a.Length;i++) Console.Write( ((i<a.Length-1) ? fs1 : fs2), a[i]);
		});
	}
	public static void WriteLines<T>(T[] a) {
		wwp(()=>{
			string fs = wfm(typeof(T)) + Environment.NewLine;
			foreach(T x in a) Console.Write(fs, x);
		});
	}



}