算法：力扣【哈希表、数学、C++、JAVA、Py3、JS】447. 回旋镖的数量

447. 回旋镖的数量

---

算法：力扣【哈希表、数学、Py3】447. 回旋镖的数量

题目描述

给定平面上 n 对互不相同的点 points，其中 points[i] = [xi, yi]。回旋镖是由点 (i, j, k) 表示的元组，其中 i 和 j 之间的距离和 i 和 k 之间的欧式距离相等（需要考虑元组的顺序）。返回平面上所有回旋镖的数量。

示例

输入

points = [[0,0],[1,0],[2,0]]

输出

2

说明

两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]

解释：

• 对于到达点 i 的距离相同的其它点，我们可以从中取出两个来组成回旋镖。因为需要考虑元组的顺序，所以相当于统计取出两个点的全排列。

思路

• 利用哈希表，统计其它点到达点 i 的各个距离的个数。
• 对于到达点 i 的距离相同的其它点，我们可以从中取出两个来组成回旋镖。因为需要考虑元组的顺序，所以相当于统计取出两个点的全排列，即$n\ast (n-1)$，$n$为到达点 i 的一个距离的数量。

Py3代码实现

from math import sqrt, pow
class Solution:
    def numberOfBoomerangs(self, points: List[List[int]]) -> int:
        n = len(points)

        def get_dist(p1: list, p2: list):
            a = p1[0] - p2[0]
            b = p1[1] - p2[1]
            return (
                    # 其实欧氏距离需要开方
                    # 但是对于计算机来说，开方会产生浮点数，
                    # 而浮点数是会有精度丢失的，
                    # 我们也不能直接转为int，因为这样会产生很多原本不相同，但是截断浮点后的数字后相同的“假相等”的数字
                    (a * a + b * b)
            )

        ans = 0
        for ii in range(n):
            i = points[ii]
            cnter = Counter()
            # 统计其它点到达点 i 的各个距离。
            for ji in range(n):
                if ii == ji: continue
                j = points[ji]
                i_to_j = get_dist(i, j)
                cnter[i_to_j] += 1
            # 对于到达点 i 的距离相同的其它点，
            # 我们可以从中取出两个来组成回旋镖
            # 因为需要考虑元组的顺序，所以相当于统计取出两个点的全排列。
            for v in cnter.values():
                ans += v * (v - 1)
        return ans

C++代码实现

#include <vector>
#include <unordered_map>

class Solution {
public:
    int numberOfBoomerangs(std::vector<std::vector<int>>& points) {
        int n = points.size();
        int ans = 0;

        for (int i = 0; i < n; ++i) {
            std::unordered_map<int, int> counter;

            for (int j = 0; j < n; ++j) {
                if (i == j) continue;

                int distance = getDist(points[i], points[j]);
                counter[distance]++;
            }

            for (const auto& entry : counter) {
                int frequency = entry.second;
                ans += frequency * (frequency - 1);
            }
        }

        return ans;
    }

private:
    int getDist(const std::vector<int>& p1, const std::vector<int>& p2) {
        int a = p1[0] - p2[0];
        int b = p1[1] - p2[1];
        return a * a + b * b;
    }
};

JAVA代码实现

import java.util.HashMap;
import java.util.Map;

class Solution {
    public int numberOfBoomerangs(int[][] points) {
        int ans = 0;
        for (int[] i : points) {
            Map<Integer, Integer> cnter = new HashMap<Integer, Integer>();
            for (int[] j : points) {
                int dist = get_dist(i, j);
                cnter.put(dist, cnter.getOrDefault(dist, 0) + 1);
            }
            for (Map.Entry<Integer, Integer> entry : cnter.entrySet()) {
                int v = entry.getValue();
                ans += v * (v - 1);
            }
        }
        return ans;

    }

    private int get_dist(int[] p1, int[] p2) {
        int a  = p1[0] - p2[0];
        int b = p1[1] - p2[1];
        return (
            a * a
              + 
            b * b
        );

    }
}

JavaScript代码实现

/**
 * @param {number[][]} points
 * @return {number}
 */
var numberOfBoomerangs = function(points) {
    let ans = 0;
    for ( let p1 of points ) {
        let cnter = new Map();
        for ( let p2 of points ) {
            let dist = get_dist(p1, p2);
            cnter.set(dist, (cnter.get(dist) || 0) + 1);
        }
        for ( let [_, v] of cnter.entries() ) {
            ans += v * (v - 1);
        } 
    }
    return ans;

};

function get_dist(p1, p2) {
            a = p1[0] - p2[0];
            b = p1[1] - p2[1];
            return (
                    (a * a + b * b)
            );

}

复杂度分析

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(n)$

总结

本算法利用哈希表统计点到达点 i 的各个距离的个数，然后对于每个距离相同的点，计算其排列数，并累加到结果中。最终，得到平面上所有回旋镖的数量。