Missing vertex among N axis-parallel rectangles
Given N axis-parallel rectangles in a 2-D Cartesian coordinate system and coordinates of 4N-1 vertices, the task is to find the single vertex missing. Examples:
Input: N = 2, V[][] = {{1, 1}, {1, 2}, {4, 6}, {2, 1}, {9, 6}, {9, 3}, {4, 3}}
Output: {2, 2}
Explanation:
The coordinates forming an axis parallel rectangle are {4, 6}, {9, 6}, {4, 3}, {9, 3}.
For the remaining coordinates to form a rectangle {1, 1}, {1, 2}, {2, 1}, the missing coordinate is {2, 2}
Input: N = 3, V[][] = {{3, 8}, {0, 0}, {4, 6}, {0, 2}, {9, 6}, {9, 3}, {4, 3}, {6, 4}, {1, 0}, {3, 4}, {6, 8}}
Output: {1, 2}
Approach:
Follow the steps below to solve the problem:
- Store the frequencies x-coordinates and y-coordinates in a Map.
- Iterate over the Map to find an element with odd frequency for both the co-ordinates.
- Finally, print the x and y coordinate with odd frequency.
Below is the implementation of the above approach:
C++
// C++ Program to implement // the above approach #include <bits/stdc++.h> using namespace std; void MissingPoint(vector<pair< int , int > > V, int N) { map< int , int > mp; for ( int i = 0; i < V.size(); i++) { mp[V[i].first]++; } int x, y; for ( auto it : mp) { if (it.second % 2 == 1) { x = it.first; break ; } } mp.clear(); for ( int i = 0; i < V.size(); i++) { mp[V[i].second]++; } for ( auto it : mp) { if (it.second % 2 == 1) { y = it.first; break ; } } cout << x << " " << y; } // Driver Code int main() { // Number of rectangles int N = 2; // Stores the coordinates vector<pair< int , int > > V; // Insert the coordinates V.push_back({ 1, 1 }); V.push_back({ 1, 2 }); V.push_back({ 4, 6 }); V.push_back({ 2, 1 }); V.push_back({ 9, 6 }); V.push_back({ 9, 3 }); V.push_back({ 4, 3 }); MissingPoint(V, N); return 0; } |
Java
// Java Program to implement // the above approach import java.util.*; class GFG{ static class pair { int first, second; public pair( int first, int second) { this .first = first; this .second = second; } } static void MissingPoint(Vector<pair> V, int N) { HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>(); for ( int i = 0 ; i < V.size(); i++) { if (mp.containsKey(V.get(i).first)) mp.put(V.get(i).first, V.get(i).first + 1 ); else mp.put(V.get(i).first, 1 ); } int x = 0 , y = 0 ; for (Map.Entry<Integer, Integer> it : mp.entrySet()) { if (it.getValue() % 2 == 1 ) { x = it.getKey(); break ; } } mp.clear(); for ( int i = 0 ; i < V.size(); i++) { if (mp.containsKey(V.get(i).second)) mp.put(V.get(i).second, V.get(i).second + 1 ); else mp.put(V.get(i).second, 1 ); } for (Map.Entry<Integer, Integer> it : mp.entrySet()) { if (it.getValue() % 2 == 1 ) { y = it.getKey(); break ; } } System.out.print(x + " " + y); } // Driver Code public static void main(String[] args) { // Number of rectangles int N = 2 ; // Stores the coordinates Vector<pair> V = new Vector<pair>(); // Insert the coordinates V.add( new pair( 1 , 1 )); V.add( new pair( 1 , 2 )); V.add( new pair( 4 , 6 )); V.add( new pair( 2 , 1 )); V.add( new pair( 9 , 6 )); V.add( new pair( 9 , 3 )); V.add( new pair( 4 , 3 )); MissingPoint(V, N); } } // This code is contributed by Rajput-Ji |
Python3
# Python3 program for the above approach from collections import defaultdict def MissingPoint(V, N): mp = defaultdict( lambda : 0 ) for i in range ( len (V)): mp[V[i][ 0 ]] + = 1 for it in mp.keys(): if (mp[it] % 2 = = 1 ): x = it break del mp mp = defaultdict( lambda : 0 ) for i in range ( len (V)): mp[V[i][ 1 ]] + = 1 for it in mp.keys(): if (mp[it] % 2 = = 1 ): y = it break print (x, y) # Driver code if __name__ = = '__main__' : # Number of rectangles N = 2 # Stores the coordinates V = [] # Insert the coordinates V.append([ 1 , 1 ]) V.append([ 1 , 2 ]) V.append([ 4 , 6 ]) V.append([ 2 , 1 ]) V.append([ 9 , 6 ]) V.append([ 9 , 3 ]) V.append([ 4 , 3 ]) MissingPoint(V, N) # This code is contributed by Shivam Singh |
C#
// C# Program to implement // the above approach using System; using System.Collections.Generic; class GFG{ class pair { public int first, second; public pair( int first, int second) { this .first = first; this .second = second; } } static void MissingPoint(List<pair> V, int N) { Dictionary< int , int > mp = new Dictionary< int , int >(); for ( int i = 0; i < V.Count; i++) { if (mp.ContainsKey(V[i].first)) mp[V[i].first] = mp[V[i].first] + 1; else mp.Add(V[i].first, 1); } int x = 0, y = 0; foreach (KeyValuePair< int , int > it in mp) { if (it.Value % 2 == 1) { x = it.Key; break ; } } mp.Clear(); for ( int i = 0; i < V.Count; i++) { if (mp.ContainsKey(V[i].second)) mp[V[i].second] = mp[V[i].second] + 1; else mp.Add(V[i].second, 1); } foreach (KeyValuePair< int , int > it in mp) { if (it.Value % 2 == 1) { y = it.Key; break ; } } Console.Write(x + " " + y); } // Driver Code public static void Main(String[] args) { // Number of rectangles int N = 2; // Stores the coordinates List<pair> V = new List<pair>(); // Insert the coordinates V.Add( new pair(1, 1)); V.Add( new pair(1, 2)); V.Add( new pair(4, 6)); V.Add( new pair(2, 1)); V.Add( new pair(9, 6)); V.Add( new pair(9, 3)); V.Add( new pair(4, 3)); MissingPoint(V, N); } } // This code is contributed by Rajput-Ji |
Javascript
//JavaScript Program to implement // the above approach function MissingPoint(V, N) { let mp = new Map(); for (let i = 0; i < V.length; i++) { if (mp.has(V[i][0])){ mp.set(V[i][0], mp.get(V[i][0]) + 1); } else { mp.set(V[i][0], 1); } } let x, y; for (const [key, value] of mp.entries()) { if (value % 2 == 1) { x = key; break ; } } mp.clear(); for (let i = 0; i < V.length; i++) { if (mp.has(V[i][1])){ mp.set(V[i][1], mp.get(V[i][1]) + 1); } else { mp.set(V[i][1], 1); } } for (const [key, value] of mp) { if (value % 2 == 1) { y = key; break ; } } console.log(x, y); } // Driver Code // Number of rectangles let N = 2; // Stores the coordinates let V = new Array(); // Insert the coordinates V.push([1, 1]); V.push([1, 2]); V.push([4, 6]); V.push([2, 1]); V.push([9, 6]); V.push([9, 3]); V.push([4, 3]); MissingPoint(V, N); // The code is contributed by gautam goel (gautamgoel962) |
2 2
Time Complexity: O(N)
Auxiliary Space: O(N)
Alternative Approach with no extra space:
Since the edges of the rectangle are axis parallel, the x and y co-ordinate of all vertices should occur even number of (at least Two) times.
Eg. For the given sample containing {{1, 1}, {1, 2}, {4, 6}, {2, 1}, {9, 6}, {9, 3}, {4, 3}} as input, the array of x co-ordinates of all the points is {1, 1, 4, 2, 9, 9, 4}.
and the array of y co-ordinates of all points is {1, 2, 6, 1, 6, 3, 3}. Here we can see that all the co-ordinate value occurs twice (even number of times) except for the missing vertex.
As XOR of any number with itself gives 0. This is valid for any even number of occurrence of that number. XOR of any number with itself that occurs odd number of times will lead to the number itself.
Since the co-ordinates of the missing vertex occur odd number of times, we can use the XOR concept to find out that vertex in O(1) space complexity.
Below is the implementation of the above approach:
C++
// C++ Program to implement // the above approach #include <bits/stdc++.h> using namespace std; void MissingPoint(vector<pair< int , int > > V, int N) { int x = 0, y = 0; for ( int i = 0; i < V.size(); i++) { x = x ^ V[i].first; y = y ^ V[i].second; } cout << x << " " << y; } // Driver Code int main() { // Number of rectangles int N = 2; // Stores the coordinates vector<pair< int , int > > V; // Insert the coordinates V.push_back({ 1, 1 }); V.push_back({ 1, 2 }); V.push_back({ 4, 6 }); V.push_back({ 2, 1 }); V.push_back({ 9, 6 }); V.push_back({ 9, 3 }); V.push_back({ 4, 3 }); MissingPoint(V, N); return 0; } |
Java
// Java Program to implement // the above approach import java.util.*; class GFG { static void MissingPoint( int [][] V, int N) { int x = 0 , y = 0 ; for ( int i = 0 ; i < V.length; i++) { x = x ^ V[i][ 0 ]; y = y ^ V[i][ 1 ]; } System.out.print(x + " " + y); } // Driver Code public static void main(String[] args) { // Number of rectangles int N = 2 ; // Stores the coordinates int [][] V = new int [][] { { 1 , 1 }, { 1 , 2 }, { 4 , 6 }, { 2 , 1 }, { 9 , 6 }, { 9 , 3 }, { 4 , 3 }}; MissingPoint(V, N); } } // This code is contributed by phasing17 |
Python3
# Python 3 program for the above approach # Function to find the missing point def MissingPoint(arr, n): missing_x = 0 missing_y = 0 for i in arr: # XORing all the x co-ordinates missing_x = missing_x ^ i[ 0 ] # XORing all the y co-ordinates missing_y = missing_y ^ i[ 1 ] print (missing_x, missing_y) if __name__ = = "__main__" : # Number of rectangles n = 2 # List of co-ordinates of known points points = [[ 1 , 1 ], [ 1 , 2 ], [ 4 , 6 ], [ 2 , 1 ], [ 9 , 6 ], [ 9 , 3 ], [ 4 , 3 ]] MissingPoint(points, n) |
C#
// C# Program to implement // the above approach using System; using System.Collections.Generic; class GFG { static void MissingPoint(List< int []> V, int N) { int x = 0, y = 0; for ( int i = 0; i < V.Count; i++) { x = x ^ V[i][0]; y = y ^ V[i][1]; } Console.Write(x + " " + y); } // Driver Code public static void Main( string [] args) { // Number of rectangles int N = 2; // Stores the coordinates List< int []> V = new List< int []>(); // Insert the coordinates V.Add( new [] {1, 1 }); V.Add( new [] {1, 2 }); V.Add( new [] {4, 6 }); V.Add( new [] {2, 1 }); V.Add( new [] {9, 6 }); V.Add( new [] {9, 3 }); V.Add( new [] {4, 3 }); MissingPoint(V, N); } } // This code is contributed by phasing17 |
Javascript
// JS Program to implement // the above approach function MissingPoint(V, N) { let x = 0, y = 0; for (let i = 0; i < V.length; i++) { x = x ^ V[i][0]; y = y ^ V[i][1]; } process.stdout.write(x + " " + y); } // Driver Code // Number of rectangles let N = 2; // Stores the coordinates let V = []; // Insert the coordinates V.push([ 1, 1 ]); V.push([ 1, 2 ]); V.push([ 4, 6 ]); V.push([ 2, 1 ]); V.push([ 9, 6 ]); V.push([ 9, 3 ]); V.push([ 4, 3 ]); MissingPoint(V, N); |
2 2
Time Complexity: O(N)
Auxiliary Space: O(1)
Contact Us