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# (.NET Core 3.1.201) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Text;

namespace AtCoder
{
  class Program
  {
    static void Main(string[] args)
    {
      int N = int.Parse(Console.ReadLine());
      List<int> xs = new List<int>();
      List<int> ys = new List<int>();
      //int minX = 0, maxX = 0, minY = 0, maxY = 0;
      for(int i = 0; i < N; i++)
      {
        string[] ss = Console.ReadLine().Split(' ');
        int x = int.Parse(ss[0]);
        int y = int.Parse(ss[1]);
        //minX = Math.Min(minX, x);
        //maxX = Math.Max(maxX, x);
        //minY = Math.Min(minY, y);
        //maxY = Math.Max(maxY, y);
        xs.Add(x);
        ys.Add(y);
      }
      //int xo = minX + maxX / 2;
      //int yo = minY + maxY / 2;
      int[] maxs = new int[4];
      int[] maxIndexes = new int[4];
      int baseX = 1, baseY = 1;
      //List<int> ts = new List<int>();
      maxIndexes[0] = GetMaxTIndex(N, xs, ys, baseX, baseY);
      baseX = 1000000000;
      baseY = 1;
      maxIndexes[1] = GetMaxTIndex(N, xs, ys, baseX, baseY);
      baseX = 1;
      baseY = 1000000000;
      maxIndexes[2] = GetMaxTIndex(N, xs, ys, baseX, baseY);
      baseX = 1000000000;
      baseY = 1000000000;
      maxIndexes[3] = GetMaxTIndex(N, xs, ys, baseX, baseY);

      for(int i = 0; i < 4; i++)
      {
        baseX = xs[maxIndexes[i]];
        baseY = ys[maxIndexes[i]];
        maxs[i] = GetMaxT(N, xs, ys, baseX, baseY);
      }

      int max = 0;
      foreach(int m in maxs)
      {
        max = Math.Max(max, m);
      }

      Console.WriteLine(max);
      Console.ReadLine();
    }

    private static int GetMaxTIndex(int N, List<int> xs, List<int> ys, int baseX, int baseY)
    {
      int result = 0;
      int max = 0;
      for(int i = 0; i < N; i++)
      {
        int t = Math.Abs(xs[i] - baseX) + Math.Abs(ys[i] - baseY);
        if(max < t)
        {
          max = t;
          result = i;
        }
      }

      return result;
    }
    private static int GetMaxT(int N, List<int> xs, List<int> ys, int baseX, int baseY)
    {
      int max = 0;
      for(int i = 0; i < N; i++)
      {
        max =Math.Max(max, Math.Abs(xs[i] - baseX) + Math.Abs(ys[i] - baseY));
      }

      return max;
    }
  }
}