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 Rust (1.42.0) (judge verdict: Accepted)

use std::collections::HashMap;

use proconio::input;

fn main() {
    input! {
        n: usize,
        ab: [(u64, u64); n],
    };
    let mut edges = HashMap::with_capacity(n * 2);
    for (a, b) in ab {
        edges.entry(a).or_insert((0, 0)).0 += 1;
        edges.entry(b).or_insert((0, 0)).1 += 1;
    }
    let mut points = edges.keys().map(|k| *k).collect::<Vec<_>>();
    points.sort();
    let ans = if n % 2 == 1 {
        let target = (n + 1) / 2;
        let mut entry = 0;
        let mut exit = 0;
        let mut ans = 1;
        for i in 0..points.len() - 1 {
            let p = points[i];
            let (a, b) = edges[&p];
            entry += a;
            exit += b;
            if entry >= target && exit < target {
                ans += points[i + 1] - p;
            }
        }
        ans
    } else {
        let target = n / 2;
        let mut entry = 0;
        let mut exit = 0;
        let mut mid1 = (None, None);
        let mut mid2 = (None, None);
        // eprintln!("{:?}", points);
        // eprintln!("{:?}", edges);
        for p in points {
            let (a, b) = edges[&p];
            entry += a;
            exit += b;
            if entry >= target && mid1.0.is_none() {
                mid1.0 = Some(p);
            }
            if entry > target && mid2.0.is_none() {
                mid2.0 = Some(p);
            }
            if exit >= target && mid1.1.is_none() {
                mid1.1 = Some(p);
            }
            if exit > target && mid2.1.is_none() {
                mid2.1 = Some(p)
            }
        }
        // eprintln!("{:?}", mid1);
        // eprintln!("{:?}", mid2);
        mid1.1.unwrap() + mid2.1.unwrap() - mid1.0.unwrap() - mid2.0.unwrap() + 1
    };
    println!("{}", ans);
}