447. Number of Boomerangs(easy)

Easy

318500FavoriteShare

Given n points in the plane that are all pairwise distinct, a "boomerang" is a tuple of points (i, j, k) such that the distance between i and j equals the distance between i and k (the order of the tuple matters).

Find the number of boomerangs. You may assume that n will be at most 500 and coordinates of points are all in the range [-10000, 10000](inclusive).

Example:

Input:

[[0,0],[1,0],[2,0]]

 

Output:

2

 

Explanation:

The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]]

 

C++:

/*
 * @Autor: SourDumplings
 * @Date: 2019-09-25 21:27:16
 * @Link: https://github.com/SourDumplings/
 * @Email: changzheng300@foxmail.com
 * @Description: https://leetcode.com/problems/number-of-boomerangs/
 */

class Solution
{
public:
    int numberOfBoomerangs(vector<vector<int>> &points)
    {
        int res = 0;
        int n = points.size();
        for (int i = 0; i < n; i++)
        {
            unordered_map<int, int> m;
            for (int j = 0; j < n; j++)
            {
                int d = (points[i][1] - points[j][1]) * (points[i][1] - points[j][1]) +
                        (points[i][0] - points[j][0]) * (points[i][0] - points[j][0]);
                ++m[d];
            }
            for (auto &&p : m)
            {
                int num = p.second;
                if (p.first != 0 && num >= 2)
                {
                    res += num * (num - 1); // A(2, num)
                }
            }
        }
        return res;
    }
};

 Java:

import java.util.Hashtable;
import java.util.Map;

/*
 * @Autor: SourDumplings
 * @Date: 2019-09-25 21:54:35
 * @Link: https://github.com/SourDumplings/
 * @Email: changzheng300@foxmail.com
 * @Description: https://leetcode.com/problems/number-of-boomerangs/
 */

class Solution
{
    public int numberOfBoomerangs(int[][] points)
    {
        int res = 0;
        int n = points.length;
        for (int i = 0; i < n; i++)
        {
            Map<Integer, Integer> m = new Hashtable<>();
            for (int j = 0; j < n; j++)
            {
                int d = (points[i][1] - points[j][1]) * (points[i][1] - points[j][1])
                        + (points[i][0] - points[j][0]) * (points[i][0] - points[j][0]);
                if (m.containsKey(d))
                {
                    m.put(d, m.get(d) + 1);
                }
                else
                {
                    m.put(d, 1);
                }
            }
            for (int k : m.keySet())
            {
                int num = m.get(k);
                if (k != 0 && num >= 2)
                {
                    res += num * (num - 1); // A(2, num)
                }
            }
        }
        return res;
    }
}