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 C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
#define endl "\n"
using namespace std;

#define ll long long
const long long llINF = 1LL << 60;
const int iINF = 0x20000000;
template<class T> inline bool chmin(T& a, T b) { if (b < a) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }

void execute();
int main() 
{
    cin.tie(nullptr);
    ios::sync_with_stdio(false);// cin と scanfの併用禁止
    cout << fixed << setprecision(15);
    execute();
    return 0;
}


void execute()
{
    ll N;
    int x[200000];
    int y[200000];
    int f[200000]={};
    cin >> N;

    vector<pair<int, int>> pos(N);
    for(int i = 0; i < N; i++){
        int x, y;
        cin >> x >> y;
        pos[i] = make_pair(x, y);
    }

    sort(pos.begin(), pos.end());

    ll ma = 0;
    int min_x = 1000000001;
    int min_y = 1000000001;
    int max_x = 0;
    int max_y = 0;
    for(int i = 0; i < N; i++){
        if(f[i]) continue;
        pair<int, int> &pi = pos[i];
        if(min_x < pi.first && pi.first < max_x &&
           min_y < pi.second && pi.second < max_y) {
               f[i] = 1;
               continue;
           }
        for(int j = 0; j < N; j++){
            if(f[j]) continue;
            pair<int, int> &pj = pos[j];
            ll dist = abs(pi.first - pj.first)
                    + abs(pi.second - pj.second);
            if(ma < dist){
                ma = dist;
                min_x = (pi.first < pj.first) ? pi.first : pj.first;
                min_y = (pi.second < pj.second) ? pi.second : pj.second;
                max_x = pi.first + pj.first - min_x;
                max_y = pi.second+pj.second - min_y;
            }
        }
    }
    cout << ma;
}