Related Articles

# Missing vertex among N axis-parallel rectangles

• Difficulty Level : Medium
• Last Updated : 11 Sep, 2020

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. Join the First-Step-to-DSA Course for Class 9 to 12 students , specifically designed to introduce data structures and algorithms to the class 9 to 12 students

My Personal Notes arrow_drop_up