N座坐标对中的一对之间的最大曼哈顿距离

给定一个由N个整数坐标组成的数组arr [] ，任务是查找任意两个不同坐标对之间的最大曼哈顿距离。

The Manhattan Distance between two points (X1, Y1) and (X2, Y2) is given by |X1 – X2| + |Y1 – Y2|.

例子：

Input: arr[] = {(1, 2), (2, 3), (3, 4)}
Output: 4
Explanation:
The maximum Manhattan distance is found between (1, 2) and (3, 4) i.e., |3 – 1| + |4- 2 | = 4.

Input: arr[] = {(-1, 2), (-4, 6), (3, -4), (-2, -4)}
Output: 17
Explanation:
The maximum Manhattan distance is found between (-4, 6) and (3, -4) i.e.,  |-4 – 3| + |6 – (-4)| = 17.

天真的方法：最简单的方法是遍历数组，并针对每个坐标，从所有剩余点计算其曼哈顿距离。继续更新每次计算后获得的最大距离。最后，打印获得的最大距离。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to calculate the maximum
// Manhattan distance
void MaxDist(vector >& A, int N)
{
    // Stores the maximum distance
    int maximum = INT_MIN;
 
    for (int i = 0; i < N; i++) {
 
        int sum = 0;
 
        for (int j = i + 1; j < N; j++) {
 
            // Find Manhattan distance
            // using the formula
            // |x1 - x2| + |y1 - y2|
            sum = abs(A[i].first - A[j].first)
                  + abs(A[i].second - A[j].second);
 
            // Updating the maximum
            maximum = max(maximum, sum);
        }
    }
 
    cout << maximum;
}
 
// Driver Code
int main()
{
    int N = 3;
 
    // Given Co-ordinates
    vector > A
        = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
 
    // Function Call
    MaxDist(A, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Pair class
    public static class Pair {
        int x;
        int y;
 
        Pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
 
    // Function to calculate the maximum
    // Manhattan distance
    static void MaxDist(ArrayList A, int N)
    {
 
        // Stores the maximum distance
        int maximum = Integer.MIN_VALUE;
 
        for (int i = 0; i < N; i++) {
            int sum = 0;
 
            for (int j = i + 1; j < N; j++) {
 
                // Find Manhattan distance
                // using the formula
                // |x1 - x2| + |y1 - y2|
                sum = Math.abs(A.get(i).x - A.get(j).x)
                      + Math.abs(A.get(i).y - A.get(j).y);
 
                // Updating the maximum
                maximum = Math.max(maximum, sum);
            }
        }
        System.out.println(maximum);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 3;
 
        ArrayList al = new ArrayList<>();
 
        // Given Co-ordinates
        Pair p1 = new Pair(1, 2);
        al.add(p1);
 
        Pair p2 = new Pair(2, 3);
        al.add(p2);
 
        Pair p3 = new Pair(3, 4);
        al.add(p3);
 
        // Function call
        MaxDist(al, n);
    }
}
 
// This code is contributed by bikram2001jha

Python3

# Python3 program for the above approach
import sys
 
# Function to calculate the maximum
# Manhattan distance
 
 
def MaxDist(A, N):
 
    # Stores the maximum distance
    maximum = - sys.maxsize
 
    for i in range(N):
        sum = 0
 
        for j in range(i + 1, N):
 
            # Find Manhattan distance
            # using the formula
            # |x1 - x2| + |y1 - y2|
            Sum = (abs(A[i][0] - A[j][0]) +
                   abs(A[i][1] - A[j][1]))
 
            # Updating the maximum
            maximum = max(maximum, Sum)
 
    print(maximum)
 
 
# Driver code
N = 3
 
# Given co-ordinates
A = [[1, 2], [2, 3], [3, 4]]
 
# Function call
MaxDist(A, N)
 
# This code is contributed by divyeshrabadiya07

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Pair class
    public class Pair {
        public int x;
        public int y;
 
        public Pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
 
    // Function to calculate the maximum
    // Manhattan distance
    static void MaxDist(List A, int N)
    {
 
        // Stores the maximum distance
        int maximum = int.MinValue;
 
        for (int i = 0; i < N; i++) {
            int sum = 0;
 
            for (int j = i + 1; j < N; j++) {
 
                // Find Manhattan distance
                // using the formula
                // |x1 - x2| + |y1 - y2|
                sum = Math.Abs(A[i].x - A[j].x)
                      + Math.Abs(A[i].y - A[j].y);
 
                // Updating the maximum
                maximum = Math.Max(maximum, sum);
            }
        }
        Console.WriteLine(maximum);
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int n = 3;
 
        List al = new List();
 
        // Given Co-ordinates
        Pair p1 = new Pair(1, 2);
        al.Add(p1);
 
        Pair p2 = new Pair(2, 3);
        al.Add(p2);
 
        Pair p3 = new Pair(3, 4);
        al.Add(p3);
 
        // Function call
        MaxDist(al, n);
    }
}
 
// This code is contributed by Amit Katiyar

输出：

4

时间复杂度： O(N ² )，其中N是给定数组的大小。
辅助空间： O(N)

高效的方法：想法是使用存储的总和以及X和Y坐标之间的差异，并通过对这些差异进行排序来找到答案。以下是对上述问题陈述的看法：

• 任意两点(X _i ，Y _i )和(X _j ，Y _j )之间的曼哈顿距离可以写成：

 |X_i – X_j| + |Y_i – Y_j| = max(X_i – X_j -Y_i + Y_j, 
                                         -X_i + X_j + Y_i – Y_j, 
                                         -X_i + X_j – Y_i + Y_j, 
                                          X_i – Xj + Y_i – Y_j).

• 上面的表达式可以重新安排为：

|X_i – X_j| + |Y_i – Y_j| = max((X_i – Y_i) – (X_j – Y_j), 
                                          (-X_i + Y_i) – (-X_j + Y_j), 
                                          (-X_i – Y_i) – (-X_j – Y_j), 
                                          (X_i + Y_i) – (X_j + Y_j))

• 从上面的表达式可以看出，可以通过存储坐标的和和差来找到答案。

请按照以下步骤解决问题：

1. 初始化两个数组sum []和diff [] 。
2. 将X和Y坐标的总和(即X _i + Y _i存储在sum []中)和它们的差即X _i – Y _i存储在diff []中。
3. 按升序对sum []和diff []进行排序。
4. 值( sum [N-1] – sum [0])和(diff [N-1] – diff [0])的最大值是必需的结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to calculate the maximum
// Manhattan distance
void MaxDist(vector >& A, int N)
{
    // Vectors to store maximum and
    // minimum of all the four forms
    vector V(N), V1(N);
 
    for (int i = 0; i < N; i++) {
        V[i] = A[i].first + A[i].second;
        V1[i] = A[i].first - A[i].second;
    }
 
    // Sorting both the vectors
    sort(V.begin(), V.end());
    sort(V1.begin(), V1.end());
 
    int maximum
        = max(V.back() - V.front(), V1.back() - V1.front());
 
    cout << maximum << endl;
}
 
// Driver Code
int main()
{
    int N = 3;
 
    // Given Co-ordinates
    vector > A
        = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
 
    // Function Call
    MaxDist(A, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Pair class
    public static class Pair {
        int x;
        int y;
 
        Pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
 
    // Function to calculate the maximum
    // Manhattan distance
    static void MaxDist(ArrayList A, int N)
    {
 
        // ArrayLists to store maximum and
        // minimum of all the four forms
        ArrayList V = new ArrayList<>();
        ArrayList V1 = new ArrayList<>();
 
        for (int i = 0; i < N; i++) {
            V.add(A.get(i).x + A.get(i).y);
            V1.add(A.get(i).x - A.get(i).y);
        }
 
        // Sorting both the ArrayLists
        Collections.sort(V);
        Collections.sort(V1);
 
        int maximum
            = Math.max((V.get(V.size() - 1) - V.get(0)),
                       (V1.get(V1.size() - 1) - V1.get(0)));
 
        System.out.println(maximum);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 3;
 
        ArrayList al = new ArrayList<>();
 
        // Given Co-ordinates
        Pair p1 = new Pair(1, 2);
        al.add(p1);
        Pair p2 = new Pair(2, 3);
        al.add(p2);
        Pair p3 = new Pair(3, 4);
        al.add(p3);
 
        // Function call
        MaxDist(al, n);
    }
}
 
// This code is contributed by bikram2001jha

Python3

# Python3 program for the above approach
 
# Function to calculate the maximum
# Manhattan distance
 
 
def MaxDist(A, N):
 
    # List to store maximum and
    # minimum of all the four forms
    V = [0 for i in range(N)]
    V1 = [0 for i in range(N)]
 
    for i in range(N):
        V[i] = A[i][0] + A[i][1]
        V1[i] = A[i][0] - A[i][1]
 
    # Sorting both the vectors
    V.sort()
    V1.sort()
 
    maximum = max(V[-1] - V[0],
                  V1[-1] - V1[0])
 
    print(maximum)
 
 
# Driver code
if __name__ == "__main__":
 
    N = 3
 
    # Given Co-ordinates
    A = [[1, 2],
         [2, 3],
         [3, 4]]
 
    # Function call
    MaxDist(A, N)
 
# This code is contributed by rutvik_56

C＃

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Pair class
    class Pair {
        public int x;
        public int y;
 
        public Pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
 
    // Function to calculate the maximum
    // Manhattan distance
    static void MaxDist(List A, int N)
    {
 
        // Lists to store maximum and
        // minimum of all the four forms
        List V = new List();
        List V1 = new List();
 
        for (int i = 0; i < N; i++) {
            V.Add(A[i].x + A[i].y);
            V1.Add(A[i].x - A[i].y);
        }
 
        // Sorting both the Lists
        V.Sort();
        V1.Sort();
 
        int maximum = Math.Max((V[V.Count - 1] - V[0]),
                               (V1[V1.Count - 1] - V1[0]));
 
        Console.WriteLine(maximum);
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int n = 3;
 
        List al = new List();
 
        // Given Co-ordinates
        Pair p1 = new Pair(1, 2);
        al.Add(p1);
        Pair p2 = new Pair(2, 3);
        al.Add(p2);
        Pair p3 = new Pair(3, 4);
        al.Add(p3);
 
        // Function call
        MaxDist(al, n);
    }
}
 
// This code is contributed by Amit Katiyar

输出：

4

时间复杂度： O(N * log N)
辅助空间： O(N)