LeetCode——2013.检测正方形

大佬，牛！！！

• 题目：本题就是给你一些节点，然后问能够构成几个三角形。节点是通过add方法进行添加的。然后需要计算个数的时候，也会输入一个节点,我们的目的就是从add进去的节点中选出三个来，与这个点组成正方形。计算个数是count方法。
  • 注意，有可能有重复的点，则视为不一样的。
  • 正方形必须是轴对齐正方形，也就是边平行于坐标轴
• 我的思路：将点存在两个map集合中，然后key是x值和y值，value是一个linked列表，记录的是这个x值对应的y值的列表。每次add的时候就找到对应的linkedlist追加进去，然后count的时候就找。找的时候给定的点我们假设为x，y，然后从同x的linkedlist中遍历y，找到y就定了边长，然后再找有没有剩下的两个点即可。至于重复的时候的个数，我这里有两个temp变量，能记录成功的，然后最后相乘即可。但是我的程序好像是有点问题。提交的时候，有测试用例不能通过。然后看了大佬的思路。
• 大佬的思路：基本和我的思路差不多，大佬用了一个map。map中嵌套一个map外层是key是y，value是一个map，这里记为map2，map2的key是x，然后value表示重复的个数。确实这样方便，而且少去了我的遍历linkedlist的时候以及temp变量。
• 技巧：
  • 就是map的应用，一定要确定好map的存储。存储什么内容一定要清晰，还有就是这里有一些map的方法。
  • getOrDefault：传入两个参数，一个是map的key，另外一个是值。也就是说，如果map中有这个key就返回对应的值，否则返回我们输入的值。
  • putIfAbsent：传递两个参数，一个是key，另外一个是值。如果map中没有这个key，就添加，并且值是我们传递进去的值。

我的代码：失败

class DetectSquares {
    // 他们的横纵坐标都一样，每次来一个点，我们都遍历对应的
    Map<Integer, LinkedList<Integer>> xMap, yMap;


    public DetectSquares() {
        xMap = new HashMap();
        yMap = new HashMap();
    }


    public void add(int[] point) {
        if (xMap.containsKey(point[0])) {
            xMap.get(point[0]).add(point[1]);
        } else {
            LinkedList<Integer> list = new LinkedList<>();
            list.add(point[1]);
            xMap.put(point[0], list);
        }
        if (yMap.containsKey(point[1])) {
            yMap.get(point[1]).add(point[0]);
        } else {
            LinkedList<Integer> list = new LinkedList<>();
            list.add(point[0]);
            yMap.put(point[1], list);
        }
    }


    public int count(int[] point) {
        if (!xMap.containsKey(point[0]) || !yMap.containsKey(point[1])) {// 同行和同列都没有
            return 0;
        } else {// 同行同列都有
            int sum = 0;
            LinkedList<Integer> yList = xMap.get(point[0]);// 固定x
            for (int y : yList) {// 遍历y，也就是固定了x
                int yAbs = Math.abs(y - point[1]);// 边长
                int x1 = point[0] + yAbs;
                int x2 = point[0] - yAbs;
                if (x1 > 1000 || x2 < 0) continue;// 一定不存在这样的点
                if (xMap.containsKey(x2)) {
                    LinkedList<Integer> yList2 = xMap.get(x2);
                    int temp1 = 0, temp2 = 0;
                    for (int y2 : yList2) {
                        if (y2 == point[1])
                            temp1++;
                        if (y2 == y)
                            temp2++;
                    }
                    if (temp1 != 0 && temp2 != 0) {
                        sum += (temp1 * temp2);
                    }
                }
                if (xMap.containsKey(x1)) {
                    LinkedList<Integer> yList2 = xMap.get(x1);
                    int temp1 = 0, temp2 = 0;
                    for (int y2 : yList2) {
                        if (y2 == point[1])
                            temp1++;
                        if (y2 == y)
                            temp2++;
                    }
                    if (temp1 != 0 && temp2 != 0) {
                        sum += (temp1 * temp2);
                    }
                }
            }
            return sum;
        }
    }
}

大佬的代码和伪代码
辅助图片：假设进来的是A点，当然B还有一个B’在A上面，一共有四种情况，这里就用abcd进行举例。

伪代码

伪代码，这里伪代码主要是说一下count的
定义的外层ymap中key是y，value是另外一个xmap，key是x，value是y和x重复的个数
假设输入进来的点是x，y，然后我们通过外层map判断是不是有这个y，如果没有，表示没有同y的，直接返回0即可。
如果有，则表示有同y的，也就是同行的，与A同行
    获取出来，记录为Amap，因为是与A同行的map，而且这个已经是一个内部的map了
    然后我们遍历这个ymap，找到所有的y，记录为By，（这里的目的是找到B这个点y，但是并不一定遍历出来的都是B这个点的，因此后面还会判断，但是先假设是B这个点的）
        我们还需要得到B这个点对应的map，也就是与B同行的map，记录为Bmap
        我们的目的是找B，因此B的y不能与A的y重合，下面是不重合的时候
            Ay-By就是边长，记录为d
            那么通过A的x就能找到C，然后通过B的x就能找到D。
            但是上面还说了，这里的B不一定与A同x，因此还需要看Bmap中的k是不是有A这个x。

java代码

class DetectSquares {
    // 他们的横纵坐标都一样，每次来一个点，我们都遍历对应的
    Map<Integer, Map<Integer, Integer>> ymap;

    public DetectSquares() {
        ymap = new HashMap<>();
    }

    public void add(int[] point) {
        ymap.putIfAbsent(point[1], new HashMap<Integer, Integer>());// 内层map，如果map是空的话，就进行put，key为y，值为map的
        Map<Integer, Integer> xMap = ymap.get(point[1]);// 获取到内层map，这时候一定有map了，要么是空，要么是有内容的
        // 内层map进行存储，key是x，value是一个数字，表示这个点的个数。getOrDefault函数的作用，如果有的话，就从内层map中获取出来，否则会返回0
        xMap.put(point[0], xMap.getOrDefault(point[0], 0) + 1);
    }

    public int count(int[] point) {
        int num = 0;
        int x = point[0], y = point[1];
        if (!ymap.containsKey(y)) {// 直接没有同行的点(y固定，也就是同行)
            return 0;
        }
        Map<Integer, Integer> aMap = ymap.get(y);// 获取出同行的所有的x，也就是内层的map
        Set<Map.Entry<Integer, Map<Integer, Integer>>> entries = ymap.entrySet();// 迭代器遍历外层map，也就是获取所有的y
        for (Map.Entry<Integer, Map<Integer, Integer>> entry : entries) {// 遍历所有的y，也就是遍历同列的
            int bY = entry.getKey();// 获取y的值
            Map<Integer, Integer> bMap = entry.getValue();// 获取这个动y上对应的x的map
            if (bY != y) {
                // 根据对称性，这里可以不用取绝对值
                int d = bY - y;// 边长
                num += bMap.getOrDefault(x, 0)// 是不是有动y同x的，也就是同列
                        * aMap.getOrDefault(x + d, 0) * bMap.getOrDefault(x + d, 0);// 同列右边的两个点
                num += bMap.getOrDefault(x, 0)// 是不是有动y同x的，也就是同列
                        * aMap.getOrDefault(x - d, 0) * bMap.getOrDefault(x - d, 0);// 同列左边边的两个点
            }
        }
        return num;
    }
}

• 总结：这个题目还可以，主要是设计数据结构，注意这里是map中嵌套map。并且这里的判断非常的巧妙，也用了很多map中的方法。