Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like 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)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!