# Find a point such that sum of the Manhattan distances is minimized

• Difficulty Level : Hard
• Last Updated : 31 Aug, 2022

Given N points in K dimensional space where and . The task is to determine the point such that the sum of Manhattan distances from this point to the N points is minimized.
Manhattan distance is the distance between two points measured along axes at right angles. In a plane with p1 at (x1, y1) and p2 at (x2, y2), it is |x1 – x2| + |y1 – y2|.

Examples:

Input: N = 3, K = 3, Points = {1, 1, 1}, {2, 2, 2}, {3, 3, 3}
Output: 2 2 2
Input: N = 4, K = 4, Points = {1, 6, 9, 6}, {5, 2, 5, 7}, {2, 0, 1, 5}, {4, 6, 3, 9}
Output: 2 2 3 6

Approach: To minimize the Manhattan distance, all we have to do is just sort the points in all K dimensions and output the middle elements of each of the K dimensions.

Below is the implementation of the above approach:

## C++

 // C++ implementation of above approach #include  using namespace std;   // Function to print the required points which // minimizes the sum of Manhattan distances void minDistance(int n, int k, vector >& point) {       // Sorting points in all k dimension     for (int i = 0; i < k; ++i)         sort(point[i].begin(), point[i].end());       // Output the required k points     for (int i = 0; i < k; ++i)         cout << point[i][(ceil((double)n / 2) - 1)] << " "; }   // Driver code int main() {       int n = 4, k = 4;     vector > point = { { 1, 5, 2, 4 },                                    { 6, 2, 0, 6 },                                    { 9, 5, 1, 3 },                                    { 6, 7, 5, 9 } };       // function call to print required points     minDistance(n, k, point);       return 0; }

## Java

 // Java implementation of above approach  import java.util.Arrays;   class GFG  {   // Function to print the required  // points which minimizes the sum  // of Manhattan distances static void minDistance(int n, int k,                         int point[][]) {           // Sorting points in all k dimension      for (int i = 0; i < k; i++)         Arrays.sort(point[i]);           // Output the required k points     for (int i = 0; i < k; i++)         System.out.print(point[i][(int)                Math.ceil((double)(n / 2) - 1)] + " "); }   // Driver code public static void main(String[] args)  {     int n = 4;     int k = 4;     int point[][] = { { 1, 5, 2, 4 },                        { 6, 2, 0, 6 },                         { 9, 5, 1, 3 },                        { 6, 7, 5, 9 } };           // function call to print required points     minDistance(n, k, point); } }   // This code is contributed by Bilal

## Python

 # Python implementation of above approach   # Function to print the required points which # minimizes the sum of Manhattan distances def minDistance(n, k, point):       # Sorting points in all dimension     for i in range(k):         point[i].sort()       # Output the required k points     for i in range(k):         print(point[i][((n + 1) // 2) - 1], end =" ")     # Driver code n = 4 k = 4 point = [[1, 5, 2, 4],          [6, 2, 0, 6],          [9, 5, 1, 3],          [6, 7, 5, 9]]   # function call to print required points minDistance(n, k, point)

## C#

 // C# implementation of above approach  using System;   class GFG  {   // Function to print the required  // points which minimizes the sum  // of Manhattan distances static void minDistance(int n, int k,                         int[][] point) {           // Sorting points in all k dimension      for (int i = 0; i < k; i++)         Array.Sort(point[i]);           // Output the required k points     for (int i = 0; i < k; i++)         System.Console.Write(point[i][(int)             Math.Ceiling((double)(n / 2) - 1)] + " "); }   // Driver code public static void Main()  {     int n = 4;     int k = 4;     int[][] point = new int[][]{ new int[]{ 1, 5, 2, 4 },                      new int[]{ 6, 2, 0, 6 },                      new int[]{ 9, 5, 1, 3 },                      new int[]{ 6, 7, 5, 9 } };           // function call to print required points     minDistance(n, k, point); } }   // This code is contributed by mits

## PHP

 

## Javascript

 

Output:

2 2 3 6

Time Complexity: O(k*nlog(n)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles