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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

var sc *bufio.Scanner

const BufferSize = 1024

func nextInt() int {
	if !sc.Scan() {
		panic(nil)
	}
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

var production bool

func debugf(format string, v ...interface{}) {
	if !production {
		fmt.Printf(format, v...)
	}
}

func answer(reader io.Reader, writer io.Writer) {
	sc = bufio.NewScanner(reader)
	buf := make([]byte, BufferSize)
	sc.Buffer(buf, 1e+6)
	sc.Split(bufio.ScanWords)
	n := nextInt()
	v := map[int]map[int]struct{}{}
	w := map[int]map[int]struct{}{}

	for i := 0; i < n; i++ {
		x := nextInt()
		y := nextInt()
		if _, ok := v[x]; !ok {
			v[x] = map[int]struct{}{}
		}
		v[x][y] = struct{}{}
		if _, ok := w[y]; !ok {
			w[y] = map[int]struct{}{}
		}
		w[y][x] = struct{}{}
	}

	debugf("v:%v, w:%v\n", v, w)

	ans := 0
	for len(v) > 0 {
		for x := range v {
			count := 0
			v1 := map[int]struct{}{x: {}}
			vSet := map[int]struct{}{x: {}}
			w1 := map[int]struct{}{}
			for len(vSet) > 0 {
				for x := range vSet {
					delete(vSet, x)
					for y := range v[x] {
						if _, ok := w1[y]; !ok {
							w1[y] = struct{}{}
							count++
							debugf("[%d], v1:%v, w1:%v\n", count, v1, w1)
						}
						for x1 := range w[y] {
							if _, ok := v1[x1]; !ok {
								v1[x1] = struct{}{}
								vSet[x1] = struct{}{}
								count++
								debugf("[%d], v1:%v, w1:%v\n", count, v1, w1)
							}
						}
					}
				}
			}
			ans += len(v1)*len(w1) - count
			debugf("v1:%v, w1:%v, ans:%d, count:%d\n", v1, w1, ans, count)
			for x1 := range v1 {
				delete(v, x1)
			}
			for y1 := range w1 {
				delete(w, y1)
			}
		}
	}

	_, _ = fmt.Fprintf(writer, "%d", ans)
}

func main() {
	production = true
	answer(os.Stdin, os.Stdout)
}