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<(i32, i32)>, (x, y): (i32, i32)) -> i32 {
    points.iter().map(|&(a, b)| (a - x).abs() + (b - y).abs()).max().unwrap_or(0)
}

fn changes(points: &Vec<(i32, i32)>) -> i32 {
    let mut top = std::i32::MIN;
    let mut bot = std::i32::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
}

fn solve(mut points: Vec<(i32, i32)>) -> i32 {
    points.sort();

    let cha = changes(&points);
    points.reverse();
    let chb = changes(&points);

    if chb > cha {
        points.reverse();
    }

    let mut top = std::i32::MIN;
    let mut bot = std::i32::MAX;
    let mut candidates = vec![];

    let a = points[0];
    let b = points[points.len() - 1];
    let mut res = (a.0 - b.0).abs() + (a.1 - b.1).abs();
    let mut ind = 0;

    while ind < points.len() {
        let orig = ind;
        let x = points[ind].0;

        while ind < points.len() && points[ind].0 == x {
            res = std::cmp::max(res, max_dist(&candidates, points[ind]));
            ind += 1;
        }

        for i in orig..ind {
            let (x, y) = points[i];
            if y > top || y < bot {
                candidates.push((x, y));
            }
            top = std::cmp::max(top, y);
            bot = std::cmp::min(bot, 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);
}