# 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 ` `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`

Output:

```2 2

```

Time Complexity: O(N)
Auxiliary Space: O(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.

My Personal Notes arrow_drop_up

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : SHIVAMSINGH67, Rajput-Ji