leetCode_447、回旋镖的数量

前言

近日偶尔在更新LeetCode上的题，也发现了，LeetCode上原来有自带的每日一题，今日pier打算更高频率的更新每日一题，每天都要练习，大家一起加油呀。

废话一堆

看过古龙的小李飞刀，你是否羡慕过？我反正羡慕过，但是看到回旋镖的数量这一道题目，眼前一亮呀，就试试做，就发现了原来还有自带的每日一题，运气不错！就来了。

原题题目

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

题目案例

题目分析

有一说一，看完题目的第一瞬间我是有一点懵的(估计是刚从困意中强行醒来)，但再次看了看我们的题目，发现大概的意思就是，我们在一个直角坐标系中存在三个点，只要三个点中的某两个点到另一个点的距离相等就可以了，然后计算我们每个点距离的公式如下：
设任意两个点p1(x1,y1),p2(x2,y2),两点距离为L；
$$L=(y2-y1{)}^2+(x1-x2{)}^2$$

代码解法

解法一

本解法十分暴力，不要拿去LeetCode运行，会导致超时。
本解法采用最原始的方式，先取出一个固定点，然后算出这个点与其他点的距离，将这个点所有的数据保存到一个ArrayList列表中，最后再将本轮数据通过简单的暴力循环对比，一旦两个数相等就将数量➕1，一轮循环过后减去一个与自己的比较。时间复杂度为O(nnn*n)=O(n^4)
代码展示

class Solution {
    public int numberOfBoomerangs(int[][] points) {
    int num=0,first1 = 0,first2=0;
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        if(points.length<3){
            return 0;
        }
        for (int i = 0; i < points.length; i++) {
            arrayList.clear();
            int length = 0;
            int[] p1 = points[i];
            for (int j = 0; j < points.length; j++) {
                int[] p2 = points[j];
                int x1 = p2[0]-p1[0];
                int x2 = p2[1] - p1[1];
                length = x1*x1+x2*x2;
                arrayList.add(length);
            }
            for(int a : arrayList){
                for(int b : arrayList){
                    if(a==b){
                        num++;
                    }
                }
                 num--;
            }
           
        }
        return num;
    }
}

解法二

本解法相对暴力，和解法一差不多，但相对时间复杂度有所优化，话不多说，上代码(没有hashMap)本轮时间复杂度为O(nnn)=O(n^3)
代码展示

class Solution {
    public int numberOfBoomerangs(int[][] points) {
    int num=0,first1 = 0,first2=0;
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        if(points.length<3){
            return 0;
        }
        for (int i = 0; i < points.length; i++) {
            arrayList.clear();
            int length = 0;
            for (int j = 0; j < points.length; j++) {
                if(i==j){
                    continue;
                }
                length = dist(points[i],points[j] );
                for (int k = 0; k < points.length; k++) {
                    if(i==k || j==k){
                        continue;
                    }
                    int length1= dist(points[j],points[k]);
                    if(length==length1){
                        num++;
                    }
                }
            }
        }
        return num;
    }
    public int dist(int[] a,int[] b){
        return (a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1]);
    }

}

LeetCode运行成功截图

解法三

由于前两种算法太过于暴力，我本想算弄一个简单点的解法，但是实在能力有限，没有想出来，于是使用的哈希法，再一次将时间复杂度提高，本次代码时间复杂度为O(n^2)

代码展示

class Solution {
    public int numberOfBoomerangs(int[][] points) {
        int num = 0, n = points.length;
        for(int i=0;i<n;i++){
            Map<Integer,Integer> cnts = new HashMap<>();
            for(int j=0;j<n;j++){
                int d = dist(points[i][0], points[j][0], points[i][1],points[j][1]);
                int v = cnts.getOrDefault(d, 0);
                cnts.put(d, v+1);
            }
            for(int val: cnts.values())
                num += val * (val - 1);
        }
        return num;
    }

    public int dist(int x1, int x2, int y1, int y2){
        return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
    }
}

LeetCode运行成功截图

Ps：每日一句毒鸡汤：别动不动说把一切交给时间，时间才懒得收拾你的烂摊子。