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

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 2Input: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**.