Pairs with same Manhattan and Euclidean distance
Last Updated :
30 Jul, 2024
In a given Cartesian plane, there are N points. The task is to find the Number of Pairs of points(A, B) such that
- Point A and Point B do not coincide.
- Manhattan Distance and the Euclidean Distance between the points should be equal.
Note: Pair of 2 points(A, B) is considered same as Pair of 2 points(B, A).
Manhattan Distance = |x2-x1|+|y2-y1|
Euclidean Distance = ((x2-x1)^2 + (y2-y1)^2)^0.5 where points are (x1, y1) and (x2, y2).
Examples:
Input: N = 3, Points = {{1, 2}, {2, 3}, {1, 3}}
Output: 2
Pairs are:
1) (1, 2) and (1, 3)
Euclidean distance of (1, 2) and (1, 3) = &root;((1 - 1)2 + (3 - 2)2) = 1
Manhattan distance of (1, 2) and (1, 3) = |(1 - 1)| + |(2 - 3)| = 1
2) (1, 3) and (2, 3)
Euclidean distance of (1, 3) and (2, 3) = &root;((1 - 2)2 + (3 - 3)2) = 1
Manhattan distance of (1, 3) and (2, 3) = |(1 - 2)| + |(3 - 3)| = 1
Input: N = 3, Points = { {1, 1}, {2, 3}, {1, 1} }
Output: 0
Here none of the pairs satisfy the above two conditions
Approach: On solving the equation
|x2-x1|+|y2-y1| = sqrt((x2-x1)^2+(y2-y1)^2)
we get , x2 = x1 or y2 = y1.
Consider 3 maps,
- Map X, where X[xi] stores the number of points having their x-coordinate equal to xi
- Map Y, where Y[yi] stores the number of points having their y-coordinate equal to yi
- Map XY, where XY[(Xi, Yi)] stores the number of points coincident with point (xi, yi)
Now,
Let Xans be the Number of pairs with same X-coordinates = X[xi]2 for all distinct xi =
Let Yans be the Number of pairs with same Y-coordinates = Y[xi]2 for all distinct yi
Let XYans be the Number of coincident points = XY[{xi, yi}]2 for all distinct points (xi, yi)
Thus the required answer = Xans + Yans - XYans
Below is the implementation of the above approach:
C++
// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to return the number of non coincident
// pairs of points with manhattan distance
// equal to euclidean distance
int findManhattanEuclidPair(pair<int, int> arr[], int n)
{
// To store frequency of all distinct Xi
map<int, int> X;
// To store Frequency of all distinct Yi
map<int, int> Y;
// To store Frequency of all distinct
// points (Xi, Yi);
map<pair<int, int>, int> XY;
for (int i = 0; i < n; i++) {
int xi = arr[i].first;
int yi = arr[i].second;
// Hash xi coordinate
X[xi]++;
// Hash yi coordinate
Y[yi]++;
// Hash the point (xi, yi)
XY[arr[i]]++;
}
int xAns = 0, yAns = 0, xyAns = 0;
// find pairs with same Xi
for (auto xCoordinatePair : X) {
int xFrequency = xCoordinatePair.second;
// calculate ((xFrequency) C2)
int sameXPairs
= (xFrequency * (xFrequency - 1)) / 2;
xAns += sameXPairs;
}
// find pairs with same Yi
for (auto yCoordinatePair : Y) {
int yFrequency = yCoordinatePair.second;
// calculate ((yFrequency) C2)
int sameYPairs
= (yFrequency * (yFrequency - 1)) / 2;
yAns += sameYPairs;
}
// find pairs with same (Xi, Yi)
for (auto XYPair : XY) {
int xyFrequency = XYPair.second;
// calculate ((xyFrequency) C2)
int samePointPairs
= (xyFrequency * (xyFrequency - 1)) / 2;
xyAns += samePointPairs;
}
return (xAns + yAns - (2 * xyAns));
/* we are subtracting 2 * xyAns because we have counted
let say A,B coinciding points two times in xAns and
yAns which should not be add to the final answer so
we are subtracting xyAns 2 times. */
}
// Driver Code
int main()
{
pair<int, int> arr[]
= { { 1, 2 }, { 1, 2 }, { 4, 3 }, { 1, 3 } };
int n = sizeof(arr) / sizeof(arr[0]);
cout << findManhattanEuclidPair(arr, n) << endl;
return 0;
}
// Java implementation of the above approach
import java.util.*;
public class GFG
{
// Function to return the number of non coincident
// pairs of points with manhattan distance
// equal to euclidean distance
static int findManhattanEuclidPair(int[][] arr, int n)
{
// To store frequency of all distinct Xi
Map<Integer, Integer> X = new HashMap<Integer, Integer>();
// To store Frequency of all distinct Yi
Map<Integer, Integer> Y = new HashMap<Integer, Integer>();
// To store Frequency of all distinct
// points (Xi, Yi);
Map<List<Integer>, Integer> XY = new HashMap<List<Integer>, Integer>();
for (int i = 0; i < n; i++) {
int xi = arr[i][0];
int yi = arr[i][1];
// Hash xi coordinate
if (!X.containsKey(xi))
X.put(xi, 0);
X.put(xi, X.get(xi) + 1);
// Hash yi coordinate
if (!Y.containsKey(yi))
Y.put(yi, 0);
Y.put(yi, Y.get(yi) + 1);
// Hash the point (xi, yi)
if (!XY.containsKey(Arrays.asList(xi, yi)))
XY.put(Arrays.asList(xi, yi), 0);
XY.put( Arrays.asList(xi, yi), XY.get(Arrays.asList(xi, yi)) + 1);
}
int xAns = 0, yAns = 0, xyAns = 0;
// find pairs with same Xi
for (Map.Entry<Integer, Integer> xCoordinatePair : X.entrySet())
{
int xFrequency = xCoordinatePair.getValue();
// calculate ((xFrequency) C2)
int sameXPairs
= (xFrequency * (xFrequency - 1)) / 2;
xAns += sameXPairs;
}
// find pairs with same Yi
for (Map.Entry<Integer, Integer> yCoordinatePair : Y.entrySet()) {
int yFrequency = yCoordinatePair.getValue();
// calculate ((yFrequency) C2)
int sameYPairs
= (yFrequency * (yFrequency - 1)) / 2;
yAns += sameYPairs;
}
// find pairs with same (Xi, Yi)
for (Map.Entry<List<Integer>, Integer> XYPair : XY.entrySet())
{
int xyFrequency = XYPair.getValue();
// calculate ((xyFrequency) C2)
int samePointPairs
= (xyFrequency * (xyFrequency - 1)) / 2;
xyAns += samePointPairs;
}
return (xAns + yAns - (2 * xyAns));
/* we are subtracting 2 * xyAns because we have counted
let say A,B coinciding points two times in xAns and
yAns which should not be add to the final answer so
we are subtracting xyAns 2 times. */
}
// Driver Code
public static void main(String[] args)
{
int[][] arr
= { { 1, 2 }, { 1, 2 }, { 4, 3 }, { 1, 3 } };
int n = arr.length;
System.out.println(findManhattanEuclidPair(arr, n));
}
}
// This code is contributed by phasing17
# Python3 implementation of the
# above approach
from collections import defaultdict
# Function to return the number of
# non coincident pairs of points with
# manhattan distance equal to
# euclidean distance
def findManhattanEuclidPair(arr, n):
# To store frequency of all distinct Xi
X = defaultdict(lambda:0)
# To store Frequency of all distinct Yi
Y = defaultdict(lambda:0)
# To store Frequency of all distinct
# points (Xi, Yi)
XY = defaultdict(lambda:0)
for i in range(0, n):
xi = arr[i][0]
yi = arr[i][1]
# Hash xi coordinate
X[xi] += 1
# Hash yi coordinate
Y[yi] += 1
# Hash the point (xi, yi)
XY[tuple(arr[i])] += 1
xAns, yAns, xyAns = 0, 0, 0
# find pairs with same Xi
for xCoordinatePair in X:
xFrequency = X[xCoordinatePair]
# calculate ((xFrequency) C2)
sameXPairs = (xFrequency *
(xFrequency - 1)) // 2
xAns += sameXPairs
# find pairs with same Yi
for yCoordinatePair in Y:
yFrequency = Y[yCoordinatePair]
# calculate ((yFrequency) C2)
sameYPairs = (yFrequency *
(yFrequency - 1)) // 2
yAns += sameYPairs
# find pairs with same (Xi, Yi)
for XYPair in XY:
xyFrequency = XY[XYPair]
# calculate ((xyFrequency) C2)
samePointPairs = (xyFrequency *
(xyFrequency - 1)) // 2
xyAns += samePointPairs
return (xAns + yAns - 2 * xyAns)
# we are subtracting 2 * xyAns because we have counted let say A,B coinciding points two times
# in xAns and yAns which should not be add to the final answer so we are subtracting xyAns 2 times.
# Driver Code
if __name__ == "__main__":
arr = [[1, 2], [1,2], [4, 3], [1, 3]]
n = len(arr)
print(findManhattanEuclidPair(arr, n))
# This code is contributed by Rituraj Jain
// C# implementation of the above approach
using System;
using System.Collections.Generic;
class GFG
{
// Function to return the number of non coincident
// pairs of points with manhattan distance
// equal to euclidean distance
static int findManhattanEuclidPair(int[, ] arr, int n)
{
// To store frequency of all distinct Xi
Dictionary<int, int> X = new Dictionary<int, int>();
// To store Frequency of all distinct Yi
Dictionary<int, int> Y = new Dictionary<int, int>();
// To store Frequency of all distinct
// points (Xi, Yi);
var XY = new Dictionary<(int first, int second), int>();
for (int i = 0; i < n; i++) {
int xi = arr[i, 0];
int yi = arr[i, 1];
// Hash xi coordinate
if (!X.ContainsKey(xi))
X[xi] = 0;
X[xi]++;
// Hash yi coordinate
if (!Y.ContainsKey(yi))
Y[yi] = 0;
Y[yi]++;
// Hash the point (xi, yi)
if (!XY.ContainsKey((xi, yi)))
XY[(xi, yi)] = 0;
XY[(xi, yi)]++;
}
int xAns = 0, yAns = 0, xyAns = 0;
// find pairs with same Xi
foreach (var xCoordinatePair in X) {
int xFrequency = xCoordinatePair.Value;
// calculate ((xFrequency) C2)
int sameXPairs
= (xFrequency * (xFrequency - 1)) / 2;
xAns += sameXPairs;
}
// find pairs with same Yi
foreach (var yCoordinatePair in Y) {
int yFrequency = yCoordinatePair.Value;
// calculate ((yFrequency) C2)
int sameYPairs
= (yFrequency * (yFrequency - 1)) / 2;
yAns += sameYPairs;
}
// find pairs with same (Xi, Yi)
foreach (var XYPair in XY) {
int xyFrequency = XYPair.Value;
// calculate ((xyFrequency) C2)
int samePointPairs
= (xyFrequency * (xyFrequency - 1)) / 2;
xyAns += samePointPairs;
}
return (xAns + yAns - (2 * xyAns));
/* we are subtracting 2 * xyAns because we have counted
let say A,B coinciding points two times in xAns and
yAns which should not be add to the final answer so
we are subtracting xyAns 2 times. */
}
// Driver Code
public static void Main(string[] args)
{
int[, ] arr
= { { 1, 2 }, { 1, 2 }, { 4, 3 }, { 1, 3 } };
int n = arr.GetLength(0);
Console.WriteLine(findManhattanEuclidPair(arr, n));
}
}
// This code is contributed by pphasing17
<script>
// JavaScript implementation of the
// above approach
function getVal(dict, val)
{
if (dict.hasOwnProperty(val))
return dict[val]
return 0
}
// Function to return the number of
// non coincident pairs of points with
// manhattan distance equal to
// euclidean distance
function findManhattanEuclidPair(arr, n)
{
// To store frequency of all distinct Xi
let X = {}
// To store Frequency of all distinct Yi
let Y = {}
// To store Frequency of all distinct
// points (Xi, Yi)
let XY = {}
for (var i = 0; i < n; i++)
{
let xi = arr[i][0]
let yi = arr[i][1]
// Hash xi coordinate
X[xi] = 1 + getVal(X, xi)
// Hash yi coordinate
Y[yi] = 1 + getVal(Y, yi)
// Hash the point (xi, yi)
XY[arr[i].join("#")] = 1 + getVal(XY, arr[i].join("#"))
}
let xAns = 0
let yAns = 0
let xyAns = 0
// find pairs with same Xi
for (const [xCoordinatePair, xFrequency] of Object.entries(X))
{
// calculate ((xFrequency) C2)
sameXPairs = Math.floor((xFrequency *
(xFrequency - 1)) / 2)
xAns += sameXPairs
}
// find pairs with same Yi
for (const [yCoordinatePair, yFrequency] of Object.entries(Y))
{
// calculate ((yFrequency) C2)
sameYPairs = Math.floor((yFrequency *
(yFrequency - 1)) / 2)
yAns += sameYPairs
}
// find pairs with same (Xi, Yi)
for (const [XYPair, xyFrequency] of Object.entries(XY))
{
// calculate ((xyFrequency) C2)
samePointPairs = Math.floor((xyFrequency *
(xyFrequency - 1)) / 2)
xyAns += samePointPairs
}
return (xAns + yAns - 2 * xyAns)
// we are subtracting 2 * xyAns because
// we have counted let say A,B coinciding points two times
// in xAns and yAns which should not be
// add to the final answer so we are subtracting xyAns 2 times.
}
// Driver Code
let arr = [[1, 2], [1,2], [4, 3], [1, 3]]
let n = arr.length
console.log(findManhattanEuclidPair(arr, n))
// This code is contributed by phasing17
</script>
Complexity Analysis:
- Time Complexity: O(NlogN), where N is the number of points
- Space Complexity: O(N), since N extra space has been taken.
Similar Reads
Find 4 points with equal Manhattan distance between any pair Given an integer N, Find 4 points in a 2D plane having integral coordinates, such that the Manhattan distance between any pair of points is equal to N. Examples: Input: N = 6Output: { {0, -3}, {3, 0}, {-3, 0}, {0, 3} }Explanation: It can be easily calculated that Manhattan distance between all possi
7 min read
Count paths with distance equal to Manhattan distance Given two points (x1, y1) and (x2, y2) in 2-D coordinate system. The task is to count all the paths whose distance is equal to the Manhattan distance between both the given points.Examples: Input: x1 = 2, y1 = 3, x2 = 4, y2 = 5 Output: 6Input: x1 = 2, y1 = 6, x2 = 4, y2 = 9 Output: 10 Approach: The
7 min read
Find the integer points (x, y) with Manhattan distance atleast N Given a number N, the task is to find the integer points (x, y) such that 0 <= x, y <= N and Manhattan distance between any two points will be atleast N.Examples: Input: N = 3 Output: (0, 0) (0, 3) (3, 0) (3, 3) Input: N = 4 Output: (0, 0) (0, 4) (4, 0) (4, 4) (2, 2) Approach: Manhattan Distan
6 min read
Minimum Sum of Euclidean Distances to all given Points Given a matrix mat[][] consisting of N pairs of the form {x, y} each denoting coordinates of N points, the task is to find the minimum sum of the Euclidean distances to all points. Examples: Input: mat[][] = { { 0, 1}, { 1, 0 }, { 1, 2 }, { 2, 1 }} Output: 4 Explanation: Average of the set of points
6 min read
CSES Solutions - Minimum Euclidean Distance Given a set of points in the two-dimensional plane, your task is to find the minimum Euclidean distance between two distinct points.The Euclidean distance of points (x1,y1) and (x2,y2) is sqrt( (x1-x2)2 + (y1-y2)2 )Example:Input: points = {{2, 1} ,{4, 4} ,{1, 2} ,{6, 3}};Output: 2Input: points = {{2
7 min read
Find a point such that sum of the Manhattan distances is minimized 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
5 min read