Problem:
Score : 500 points

Problem Statement

There are N integers X_1, X_2, \cdots, X_N, and we know that A_i \leq X_i \leq B_i.
Find the number of different values that the median of X_1, X_2, \cdots, X_N can take.

Notes

The median of X_1, X_2, \cdots, X_N is defined as follows. Let x_1, x_2, \cdots, x_N be the result of sorting X_1, X_2, \cdots, X_N in ascending order.

If N is odd, the median is x_{(N+1)/2};

if N is even, the median is (x_{N/2} + x_{N/2+1}) / 2.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq A_i \leq B_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 B_1
A_2 B_2
:
A_N B_N

Output

Print the answer.

Sample Input 1

2
1 2
2 3

Sample Output 1

3

If X_1 = 1 and X_2 = 2, the median is \frac{3}{2};

if X_1 = 1 and X_2 = 3, the median is 2;

if X_1 = 2 and X_2 = 2, the median is 2;

if X_1 = 2 and X_2 = 3, the median is \frac{5}{2}.

Thus, the median can take three values: \frac{3}{2}, 2, and \frac{5}{2}.

Sample Input 2

3
100 100
10 10000
1 1000000000

Sample Output 2

9991

Solution in Java (OpenJDK 11.0.6) (judge verdict: Wrong Answer)

	import java.util.*;
	import java.util.Map.Entry;
	 
	 
	 class Main {
		 static int mod =  (int) (Math.pow(10,9)+7);
//		 static int mod =  (int) 998244353;
		 public static void main(String[] args) {
	    	
	        Scanner sc = new Scanner(System.in);

	        
	        int N = sc.nextInt();
	        Integer[][] a = new Integer[N][3];
	        Integer[][] b = new Integer[N][3];
	        for(int i=0;i<N;i++) {
	        	a[i][0] = Integer.parseInt(sc.next());
	        	a[i][1] = Integer.parseInt(sc.next());
	        	a[i][2] = i;
	        	b[i][0] = a[i][0];
	        	b[i][1] = a[i][1];
	        	b[i][2] = a[i][2];
	        }
	        Arrays.sort(a, (d, c) -> Integer.compare(d[0], c[0]));
	        Arrays.sort(b, (d, c) -> Integer.compare(c[1], d[1]));
	        long ans=0;
	        if(N%2==1) {
	        	Integer min = a[N/2][0];
	        	Integer max = b[N/2][1];
        		Integer r = 0;
        		ans=max-min+1;
	        	for(int i=0;i<N;i++) {
	        		if(r>=max)break;
	        		if(r<a[i][0]&&min<a[i][0]) {
	        			ans=ans-(Math.min(a[i][0], max)-Math.max(r, min)-1);
	        		}
	        		r=Math.max(r, a[i][1]);
	        	}
	        	
	        } else {
	        	Integer min = a[N/2-1][0];
	        	Integer max = b[N/2-1][1];
	        	Integer k = b[N/2-1][2];
	        	Integer r = 0;
        		ans=(max-min+1)*2;
	        	for(int i=0;i<N;i++) {
	        		if(i==N/2-1)continue;
	        		if(a[i][2]==k)continue;
	        		if(r>=max)break;
	        		if(r<a[i][0]&&min<a[i][0]) {
	        			ans=ans-(Math.min(a[i][0], max+1)-Math.max(r, min-1)-1);
	        		}
	        		r=Math.max(r, a[i][1]);
	        	}
	        	
	        }
	        
	        System.out.println(ans);
	    }
	}