<p>There is an integer array <code>nums</code> that consists of <code>n</code> <strong>unique </strong>elements, but you have forgotten it. However, you do remember every pair of adjacent elements in <code>nums</code>.</p>

<p>You are given a 2D integer array <code>adjacentPairs</code> of size <code>n - 1</code> where each <code>adjacentPairs[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> indicates that the elements <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> are adjacent in <code>nums</code>.</p>

<p>It is guaranteed that every adjacent pair of elements <code>nums[i]</code> and <code>nums[i+1]</code> will exist in <code>adjacentPairs</code>, either as <code>[nums[i], nums[i+1]]</code> or <code>[nums[i+1], nums[i]]</code>. The pairs can appear <strong>in any order</strong>.</p>

<p>Return <em>the original array </em><code>nums</code><em>. If there are multiple solutions, return <strong>any of them</strong></em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> adjacentPairs = [[2,1],[3,4],[3,2]]
<strong>Output:</strong> [1,2,3,4]
<strong>Explanation:</strong> This array has all its adjacent pairs in adjacentPairs.
Notice that adjacentPairs[i] may not be in left-to-right order.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> adjacentPairs = [[4,-2],[1,4],[-3,1]]
<strong>Output:</strong> [-2,4,1,-3]
<strong>Explanation:</strong> There can be negative numbers.
Another solution is [-3,1,4,-2], which would also be accepted.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> adjacentPairs = [[100000,-100000]]
<strong>Output:</strong> [100000,-100000]
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>nums.length == n</code></li>
	<li><code>adjacentPairs.length == n - 1</code></li>
	<li><code>adjacentPairs[i].length == 2</code></li>
	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>-10<sup>5</sup> &lt;= nums[i], u<sub>i</sub>, v<sub>i</sub> &lt;= 10<sup>5</sup></code></li>
	<li>There exists some <code>nums</code> that has <code>adjacentPairs</code> as its pairs.</li>
</ul>

class Solution {
public:
std::vector<int> restoreArray(std::vector<std::vector<int>>& adjacentPairs)
{
    if (adjacentPairs.size() == 1)
        return { adjacentPairs[0][0], adjacentPairs[0][1] };
    std::unordered_map<int, std::vector<int>> map;
    for (const std::vector<int>& pair : adjacentPairs) {
        if (map.contains(pair[0]))
            map[pair[0]].push_back(pair[1]);
        else
            map.insert({ pair[0], std::vector<int>{ pair[1] } });
        if (map.contains(pair[1]))
            map[pair[1]].push_back(pair[0]);
        else
            map.insert({ pair[1], std::vector<int>{ pair[0] } });
    }
    std::vector<int> start;
    std::vector<int> end;
    for (const auto& stuff : map) {
        if (stuff.second.size() == 2) {
            start.push_back(stuff.first);
            start.push_back(stuff.second[0]);
            end.push_back(stuff.first);
            end.push_back(stuff.second[1]);
            break;
        }
    }
    int start_end = start[1];
    while (map[start_end].size() == 2) {
        for (int num : map[start_end]) {
            if (num != start[start.size() - 2]) {
                start_end = num;
                start.push_back(num);
                break;
            }
        }
    }
    int end_end = end[1];
    while (map[end_end].size() == 2) {
        for (int num : map[end_end]) {
            if (num != end[end.size() - 2]) {
                end_end = num;
                end.push_back(num);
                break;
            }
        }
    }
    std::reverse(start.begin(), start.end());
    start.insert(start.end(), end.begin() + 1, end.end());
    return start;
}
};
90019