# Missing vertex among N axis-parallel rectangles

• Difficulty Level : Medium
• Last Updated : 25 Oct, 2022

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 ``using` `namespace` `std;` `void` `MissingPoint(vector > 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 > 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 V, ``int` `N)``{``    ``HashMap mp = ``new` `HashMap();``    ``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 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 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 V = ``new` `Vector();` `    ``// 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 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 V = ``new` `List();` `  ``// 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)`

Output

`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 ``using` `namespace` `std;` `void` `MissingPoint(vector > 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 > 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);`

Output

`2 2`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up