Problem:
Score : 500 points

Problem Statement

There are N points on the 2D plane, i-th of which is located on (x_i, y_i).
There can be multiple points that share the same coordinate.
What is the maximum possible Manhattan distance between two distinct points?

Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.

Constraints

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

1 \leq x_i,y_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_N y_N

Output

Print the answer.

Sample Input 1

3
1 1
2 4
3 2

Sample Output 1

4

The Manhattan distance between the first point and the second point is |1-2|+|1-4|=4, which is maximum possible.

Sample Input 2

2
1 1
1 1

Sample Output 2

0

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

use std::fmt::Debug;
use std::str::FromStr;

pub struct TokenReader {
    reader: std::io::Stdin,
    tokens: Vec<String>,
    index: usize,
}

impl TokenReader {
    pub fn new() -> Self {
        Self {
            reader: std::io::stdin(),
            tokens: Vec::new(),
            index: 0,
        }
    }

    pub fn next<T>(&mut self) -> T
    where
        T: FromStr,
        T::Err: Debug,
    {
        if self.index >= self.tokens.len() {
            self.load_next_line();
        }
        self.index += 1;
        self.tokens[self.index - 1].parse().unwrap()
    }

    pub fn vector<T>(&mut self) -> Vec<T>
    where
        T: FromStr,
        T::Err: Debug,
    {
        if self.index >= self.tokens.len() {
            self.load_next_line();
        }
        self.index = self.tokens.len();
        self.tokens.iter().map(|tok| tok.parse().unwrap()).collect()
    }

    pub fn load_next_line(&mut self) {
        let mut line = String::new();
        self.reader.read_line(&mut line).unwrap();

        self.tokens = line.split_whitespace().map(String::from).collect();
        self.index = 0;
    }
}

fn max_dist(points: &Vec<(i64, i64)>, (x, y): (i64, i64)) -> i64 {
    points
        .iter()
        .map(|&(a, b)| (a - x).abs() + (b - y).abs())
        .max()
        .unwrap_or(0)
}

fn should_rev(points: &Vec<(i64, i64)>) -> bool {
    let mut top = std::i64::MIN;
    let mut bot = std::i64::MAX;
    let mut changes = 0;

    for &(_, y) in points.iter() {
        if y >= top {
            top = y;
            changes += 1;
        }
        if y <= bot {
            bot = y;
            changes += 1;
        }
    }
    changes > 1000
}

fn solve(mut points: Vec<(i64, i64)>) -> i64 {
    points.sort();
    if should_rev(&points) {
        points.reverse();
    }

    let mut tops = vec![];
    let mut bots = vec![];

    let mut res = 0;
    for (x, y) in points {
        res = std::cmp::max(res, max_dist(&tops, (x, y)));
        res = std::cmp::max(res, max_dist(&bots, (x, y)));

        if tops.is_empty() || tops.last().unwrap().0 <= y {
            tops.push((x, y));
        }
        if bots.is_empty() || bots.last().unwrap().0 >= y {
            bots.push((x, y));
        }
    }
    res
}

fn main() {
    let mut reader = TokenReader::new();
    let n = reader.next();
    let points = (0..n).map(|_| (reader.next(), reader.next())).collect();

    let res = solve(points);
    println!("{}", res);
}