Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Hard
  • Last Updated : 19 May, 2021

Given N points in K dimensional space where 2\leq N\leq 10^{5} and 1\leq K\leq 5. 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 <bits/stdc++.h>
using namespace std;
 
// Function to print the required points which
// minimizes the sum of Manhattan distances
void minDistance(int n, int k, vector<vector<int> >& 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<vector<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);
 
    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




<?php
// PHP implementation of above approach
 
// Function to print the required
// points which minimizes the sum
// of Manhattan distances
function minDistance($n, $k, &$point)
{
 
    // Sorting points in all
    // k dimension
    for ($i = 0; $i < $k; ++$i)
        sort($point[$i]);
 
    // Output the required k points
    for ($i = 0; $i < $k; ++$i)
        echo $point[$i][(ceil(
            (double)$n / 2) - 1)] . " ";
}
 
// Driver code
$n = 4;
$k = 4;
$point = array(array( 1, 5, 2, 4 ),
               array( 6, 2, 0, 6 ),
               array( 9, 5, 1, 3 ),
               array( 6, 7, 5, 9 ));
 
// function call to print
// required points
minDistance($n, $k, $point);
 
// This code is contributed
// by ChitraNayal
?>

Javascript




<script>
// Javascript implementation of above approach
     
// Function to print the required
// points which minimizes the sum
// of Manhattan distances
    function minDistance(n,k,points)
    {
        // Sorting points in all k dimension
        for (let i = 0; i < k; i++)
            (point[i]).sort(function(a,b){return a-b;});
       
        // Output the required k points
        for (let i = 0; i < k; i++)
            document.write(point[i][
               Math.ceil((n / 2) - 1)] + " ");
    }
     
    // Driver code
    let n = 4;
    let k = 4;
    let 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 rag2127
</script>
Output: 
2 2 3 6

 

Time Complexity: O(k*nlog(n)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :