Problem:
Score: 400 points

Problem Statement

In Takahashi Kingdom, there is a east-west railroad and N cities along it, numbered 1, 2, 3, ..., N from west to east.
A company called AtCoder Express possesses M trains, and the train i runs from City L_i to City R_i (it is possible that L_i = R_i).
Takahashi the king is interested in the following Q matters:

The number of the trains that runs strictly within the section from City p_i to City q_i, that is, the number of trains j such that p_i \leq L_j and R_j \leq q_i.

Although he is genius, this is too much data to process by himself. Find the answer for each of these Q queries to help him.

Constraints

N is an integer between 1 and 500 (inclusive).

M is an integer between 1 and 200 \ 000 (inclusive).

Q is an integer between 1 and 100 \ 000 (inclusive).

1 \leq L_i \leq R_i \leq N (1 \leq i \leq M)

1 \leq p_i \leq q_i \leq N (1 \leq i \leq Q)

Input

Input is given from Standard Input in the following format:

N M Q
L_1 R_1
L_2 R_2
:
L_M R_M
p_1 q_1
p_2 q_2
:
p_Q q_Q

Output

Print Q lines. The i-th line should contain the number of the trains that runs strictly within the section from City p_i to City q_i.

Sample Input 1

2 3 1
1 1
1 2
2 2
1 2

Sample Output 1

3

As all the trains runs within the section from City 1 to City 2, the answer to the only query is 3.

Sample Input 2

10 3 2
1 5
2 8
7 10
1 7
3 10

Sample Output 2

1
1

The first query is on the section from City 1 to 7. There is only one train that runs strictly within that section: Train 1.
The second query is on the section from City 3 to 10. There is only one train that runs strictly within that section: Train 3.

Sample Input 3

10 10 10
1 6
2 9
4 5
4 7
4 7
5 8
6 6
6 7
7 9
10 10
1 8
1 9
1 10
2 8
2 9
2 10
3 8
3 9
3 10
1 10

Sample Output 3

7
9
10
6
8
9
6
7
8
10

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

#![allow(unused)]

use std::{cell, cmp, collections, fmt, ops};

use cell::{Cell, RefCell};
use cmp::Ordering::{Equal, Greater, Less};
use collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
use fmt::{Debug, Display};

#[cfg(feature = "debug")]
macro_rules! debug {
    ($($args: tt)*) => { eprint!($($args)*) };
}

#[cfg(feature = "debug")]
macro_rules! debugln {
    ($($args: tt)*) => { eprintln!($($args)*) };
}

#[cfg(not(feature = "debug"))]
macro_rules! debug {
    ($($args:tt)*) => {};
}

#[cfg(not(feature = "debug"))]
macro_rules! debugln {
    ($($args:tt)*) => {};
}

macro_rules! vmin {
    ($x: expr, $y: expr) => { cmp::min($x, $y) };
    ($x: expr, $($args: expr),*) => { cmp::min($x, vmin!($($args),*)) };
}

macro_rules! vmax {
    ($x: expr, $y: expr) => { cmp::max($x, $y) };
    ($x: expr, $($args: expr),*) => { cmp::max($x, vmax!($($args),*)) };
}

fn main() {
    use interval_tree::*;
    use io::*;

    let (n, m, q) = {
        let nmq = parse_vec::<usize>();
        (nmq[0], nmq[1], nmq[2])
    };

    let mut train_ranges = IntervalTree::new(1..(n + 1));
    let mut multi = HashMap::new();

    for _ in 0..m {
        let lr = parse_vec::<usize>();
        let interval = lr[0]..(lr[1] + 1);

        let mut e = multi.entry(interval.clone()).or_insert(0);
        *e += 1;

        train_ranges.insert(interval);
    }

    for _ in 0..q {
        let pq = parse_vec::<usize>();
        let query = pq[0]..(pq[1] + 1);

        let trains = train_ranges.contains_interval(query);
        let ans = trains.len() + trains.iter().map(|t| multi[*t] - 1).sum::<usize>();

        println!("{}", ans);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        //
    }
}

mod io {
    use std::io::{self, Read, Write};
    use std::str;

    pub fn read_line() -> String {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        buf.trim().to_owned()
    }

    pub fn read_word() -> String {
        const CAPACITY: usize = 16;

        let mut stdin = io::stdin();
        let mut byte: [u8; 1] = [0];

        loop {
            let mut buf = Vec::with_capacity(CAPACITY);

            loop {
                let res = stdin.read(&mut byte);

                if res.unwrap_or(0) == 0 || byte[0] <= b' ' {
                    break;
                } else {
                    buf.push(byte[0]);
                }
            }

            if !buf.is_empty() {
                return String::from_utf8(buf).unwrap();
            }
        }
    }

    pub fn parse_line<T: str::FromStr>() -> T {
        read_line().parse().ok().unwrap()
    }

    pub fn parse_word<T: str::FromStr>() -> T {
        read_word().parse().ok().unwrap()
    }

    pub fn parse_vec<T: str::FromStr>() -> Vec<T> {
        read_line()
            .split_whitespace()
            .map(|e| e.parse().ok().unwrap())
            .collect()
    }

    pub fn flush() {
        io::stdout().flush();
    }
}

mod num {
    use std::{cmp, ops};

    pub fn imin<T, I>(v: &T) -> &I
    where
        T: ops::Deref<Target = [I]>,
        I: cmp::Ord + Copy,
    {
        v.iter().min().unwrap()
    }

    pub fn imax<T, I>(v: &T) -> &I
    where
        T: ops::Deref<Target = [I]>,
        I: cmp::Ord + Copy,
    {
        v.iter().max().unwrap()
    }

    pub fn next_prime(x: i32) -> i32 {
        for i in (x + 1).. {
            if is_prime(i) {
                return i;
            }
        }

        panic!("attempt to add with overflow");
    }

    pub fn is_prime(x: i32) -> bool {
        let ceil = f64::from(x).sqrt().ceil() as i32;
        x == 2 || (2..(ceil + 1)).all(|i| x % i != 0)
    }
}

mod bits {
    pub fn bit_high(bits: u64, pos: u64) -> bool {
        bits & (1 << pos) != 0
    }
}

mod interval_tree {
    use std::cmp::Ordering;
    use std::collections::{BinaryHeap, HashSet};
    use std::hash::Hash;
    use std::ops::{Deref, Range};

    pub trait Interval: Clone + Eq + Hash + Iterator {
        fn begin(&self) -> Self::Item;
        fn end(&self) -> Self::Item;

        fn center(&self) -> Self::Item;

        fn left_half(&self) -> Self;
        fn right_half(&self) -> Self;

        fn to_begin_sorted(&self) -> BeginSorted<Self>;
        fn to_end_sorted(&self) -> EndSorted<Self>;
    }

    #[derive(Debug, PartialEq, Eq)]
    pub struct BeginSorted<T: Interval>(T);

    #[derive(Debug, PartialEq, Eq)]
    pub struct EndSorted<T: Interval>(T);

    impl<T: Interval> Deref for BeginSorted<T> {
        type Target = T;

        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    impl<T: Interval> Deref for EndSorted<T> {
        type Target = T;

        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    macro_rules! impl_interval_for_range {
        ($int:ty) => {
            impl Interval for Range<$int> {
                fn begin(&self) -> Self::Item {
                    self.start
                }

                fn end(&self) -> Self::Item {
                    self.end
                }

                fn center(&self) -> Self::Item {
                    (self.start + self.end) / 2
                }

                fn left_half(&self) -> Self {
                    self.begin()..self.center()
                }

                fn right_half(&self) -> Self {
                    self.center()..self.end()
                }

                fn to_begin_sorted(&self) -> BeginSorted<Self> {
                    BeginSorted(self.clone())
                }

                fn to_end_sorted(&self) -> EndSorted<Self> {
                    EndSorted(self.clone())
                }
            }

            impl Ord for BeginSorted<Range<$int>> {
                fn cmp(&self, rhs: &Self) -> Ordering {
                    self.start.cmp(&rhs.start)
                }
            }

            impl PartialOrd for BeginSorted<Range<$int>> {
                fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
                    Some(self.cmp(&rhs))
                }
            }

            impl Ord for EndSorted<Range<$int>> {
                fn cmp(&self, rhs: &Self) -> Ordering {
                    rhs.end.cmp(&self.end)
                }
            }

            impl PartialOrd for EndSorted<Range<$int>> {
                fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
                    Some(self.cmp(&rhs))
                }
            }
        };
    }

    impl_interval_for_range!(u8);
    impl_interval_for_range!(i8);
    impl_interval_for_range!(u16);
    impl_interval_for_range!(i16);
    impl_interval_for_range!(u32);
    impl_interval_for_range!(i32);
    impl_interval_for_range!(u64);
    impl_interval_for_range!(i64);
    // impl_interval_for_range!(u128);
    // impl_interval_for_range!(i128);
    impl_interval_for_range!(usize);
    impl_interval_for_range!(isize);

    /// Interval tree.
    #[derive(Debug)]
    pub struct IntervalTree<T>
    where
        T: Interval,
        BeginSorted<T>: Ord,
        EndSorted<T>: Ord,
    {
        range: T,
        center: T::Item,

        left: Option<Box<IntervalTree<T>>>,
        right: Option<Box<IntervalTree<T>>>,

        overlaps_begin: BinaryHeap<BeginSorted<T>>,
        overlaps_end: BinaryHeap<EndSorted<T>>,
    }

    impl<T> IntervalTree<T>
    where
        T: Interval,
        <T as Iterator>::Item: PartialOrd + Copy,
        BeginSorted<T>: Ord,
        EndSorted<T>: Ord,
    {
        pub fn new(range: T) -> Self {
            let center = range.center();

            IntervalTree {
                range: range,
                center: center,

                left: None,
                right: None,

                overlaps_begin: BinaryHeap::new(),
                overlaps_end: BinaryHeap::new(),
            }
        }

        pub fn insert(&mut self, interval: T) {
            assert!(!self.overflow_interval(&interval));

            if interval.end() <= self.center {
                if self.left.is_none() {
                    let range = self.range.left_half();
                    self.left = Some(Box::new(IntervalTree::new(range)));
                }

                self.left.as_mut().unwrap().insert(interval);
            } else if interval.begin() > self.center {
                if self.right.is_none() {
                    let range = self.range.right_half();
                    self.right = Some(Box::new(IntervalTree::new(range)));
                }

                self.right.as_mut().unwrap().insert(interval);
            } else {
                self.overlaps_begin.push(interval.to_begin_sorted());
                self.overlaps_end.push(interval.to_end_sorted());
            }
        }

        pub fn contains_point(&self, point: T::Item) -> HashSet<&T> {
            assert!(!self.overflow_point(&point));

            let mut found = HashSet::new();
            self.contains_point_rec(point, &mut found);
            found
        }

        fn contains_point_rec<'a, 'b>(&'a self, point: T::Item, found: &'b mut HashSet<&'a T>) {
            if point < self.center {
                for intv in self
                    .overlaps_begin
                    .iter()
                    .filter(|&intv| intv.begin() <= point)
                {
                    found.insert(&intv);
                }

                if let Some(ref left) = self.left {
                    left.contains_point_rec(point, found);
                }
            } else {
                for intv in self.overlaps_end.iter().filter(|intv| intv.end() > point) {
                    found.insert(&intv);
                }

                if let Some(ref right) = self.right {
                    right.contains_point_rec(point, found);
                }
            }
        }

        pub fn overlaps(&self, interval: T) -> HashSet<&T> {
            assert!(!self.overflow_interval(&interval));

            let mut found = HashSet::new();
            for p in interval {
                for intv in self.contains_point(p) {
                    found.insert(intv);
                }
            }

            found
        }

        pub fn contains_interval(&self, interval: T) -> HashSet<&T> {
            assert!(!self.overflow_interval(&interval));

            let mut found = HashSet::new();

            let (begin, end) = (interval.begin(), interval.end());

            for p in interval {
                for intv in self
                    .contains_point(p)
                    .into_iter()
                    .filter(|intv| intv.begin() >= begin && intv.end() <= end)
                {
                    found.insert(intv);
                }
            }

            found
        }

        fn overflow_interval(&self, interval: &T) -> bool {
            interval.begin() < self.range.begin() || interval.end() > self.range.end()
        }

        fn overflow_point(&self, point: &T::Item) -> bool {
            point < &self.range.begin() || point >= &self.range.end()
        }
    }
}