<p>Given an integer array of even length <code>arr</code>, return <code>true</code><em> if it is possible to reorder </em><code>arr</code><em> such that </em><code>arr[2 * i + 1] = 2 * arr[2 * i]</code><em> for every </em><code>0 &lt;= i &lt; len(arr) / 2</code><em>, or </em><code>false</code><em> otherwise</em>.</p>

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

<pre>
<strong>Input:</strong> arr = [3,1,3,6]
<strong>Output:</strong> false
</pre>

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

<pre>
<strong>Input:</strong> arr = [2,1,2,6]
<strong>Output:</strong> false
</pre>

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

<pre>
<strong>Input:</strong> arr = [4,-2,2,-4]
<strong>Output:</strong> true
<strong>Explanation:</strong> We can take two groups, [-2,-4] and [2,4] to form [-2,-4,2,4] or [2,4,-2,-4].
</pre>

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

<ul>
	<li><code>2 &lt;= arr.length &lt;= 3 * 10<sup>4</sup></code></li>
	<li><code>arr.length</code> is even.</li>
	<li><code>-10<sup>5</sup> &lt;= arr[i] &lt;= 10<sup>5</sup></code></li>
</ul>

class Solution {
public:
    bool canReorderDoubled(vector<int>& arr) {
        vector<int> t;
        unordered_map<int, int> m;
        int temp, zero=0;
        for (int i=0; i!=arr.size(); i++)
        {
            if (arr[i]>0)
            {
                t.push_back(arr[i]);
                m[arr[i]]++;
            }
            else if (arr[i]==0) zero++;
        }
        if (zero%2!=0) return 0;
        if (t.size()>0)
        {
            sort(t.begin(), t.end());
            int i=0;
            while (i<t.size()&&m.size()>0)
            {
                temp=2*t[i];
                if (m.count(t[i])>0&&m[t[i]]>0&&m.count(temp)>0&&m[temp]>0)
                {
                    m[temp]--;
                    m[t[i]]--;
                    if (m[temp]==0) m.erase(temp);
                    if (m[t[i]]==0) m.erase(t[i]);
                }
                else if (m.count(t[i])>0&&m[t[i]]>0) return 0;
                i++;
            }
        }
        m.clear();
        t.clear();
        for (int i=0; i!=arr.size(); i++)
        {
            if (arr[i]<0)
            {
                t.push_back(arr[i]);
                m[arr[i]]++;
            }
        }
        if (t.size()>0)
        {
            sort(t.begin(), t.end());
            int i=0;
            while (i<t.size()&&m.size()>0)
            {
                temp=t[i];
                if (t[i]%2==0&&m.count(temp/2)>0&&m[temp/2]>0&&m.count(temp)>0&&m[temp]>0)
                {
                    m[temp]--;
                    m[temp/2]--;
                    if (m[temp]==0) m.erase(temp);
                    if (m[temp/2]==0) m.erase(temp/2);
                }
                else if (m.count(temp)>0&&m[temp]>0) return 0;
                i++;
            }
        }
        return 1;
    }
};
65000