<p>You are given <code>n</code> <code>points</code> in the plane that are all <strong>distinct</strong>, where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>. A <strong>boomerang</strong> is a tuple of points <code>(i, j, k)</code> such that the distance between <code>i</code> and <code>j</code> equals the distance between <code>i</code> and <code>k</code> <strong>(the order of the tuple matters)</strong>.</p>

<p>Return <em>the number of boomerangs</em>.</p>

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

<pre>
<strong>Input:</strong> points = [[0,0],[1,0],[2,0]]
<strong>Output:</strong> 2
<strong>Explanation:</strong> The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]].
</pre>

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

<pre>
<strong>Input:</strong> points = [[1,1],[2,2],[3,3]]
<strong>Output:</strong> 2
</pre>

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

<pre>
<strong>Input:</strong> points = [[1,1]]
<strong>Output:</strong> 0
</pre>

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

<ul>
	<li><code>n == points.length</code></li>
	<li><code>1 &lt;= n &lt;= 500</code></li>
	<li><code>points[i].length == 2</code></li>
	<li><code>-10<sup>4</sup> &lt;= x<sub>i</sub>, y<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
	<li>All the points are <strong>unique</strong>.</li>
</ul>

class Solution 
{
public:
    int numberOfBoomerangs(vector<vector<int>>& points) 
    {
        std::function<int(std::vector<int> const&, std::vector<int> const&)>
        get_distance = [](std::vector<int> const& point_A, std::vector<int> const& point_B) -> int
        {
            return (point_B[1] - point_A[1]) * (point_B[1] - point_A[1]) +
                   (point_B[0] - point_A[0]) * (point_B[0] - point_A[0]);
        };   // End of get_distance() lambda function.  

        int result_num_boomerangs{0};

        for(size_t left_pos{0}; left_pos < points.size(); ++left_pos)
        {            
            std::unordered_map<int,int> distance_to_frequency_map{};
       
            for(size_t right_pos{0}; right_pos < points.size(); ++right_pos)
            {
                if(left_pos == right_pos)
                {
                    continue;
                }

                int cur_distance{get_distance(points[left_pos], points[right_pos])};

                ++distance_to_frequency_map[cur_distance];
            }

            for(auto& [cur_distance, cur_frequency] : distance_to_frequency_map)
            {
                result_num_boomerangs += (cur_frequency * (cur_frequency -1));
            }
        }

        return result_num_boomerangs;
    }
};
69056