LeetCode刷题【391】完美矩形

给你一个数组 rectangles ，其中 rectangles[i] = [xi, yi, ai, bi] 表示一个坐标轴平行的矩形。这个矩形的左下顶点是 (xi, yi) ，右上顶点是 (ai, bi) 。

如果所有矩形一起精确覆盖了某个矩形区域，则返回 true ；否则，返回 false 。

示例 1：

输入：rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]
输出：true
解释：5 个矩形一起可以精确地覆盖一个矩形区域。 

示例 2：

输入：rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]
输出：false
解释：两个矩形之间有间隔，无法覆盖成一个矩形。

示例 3：

输入：rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]
输出：false
解释：因为中间有相交区域，虽然形成了矩形，但不是精确覆盖。

提示：

• 1 <= rectangles.length <= 2 * 104
• rectangles[i].length == 4
• -105 <= xi, yi, ai, bi <= 105

依葫芦画瓢

class Solution {


    public boolean isRectangleCover(int[][] rectangles) {
        HashMap<String,Integer> hashMap = new HashMap<>();
        HashSet<String> hashSetSingle = new HashSet<>();
        int totalArea = 0;
        int[] bigRectangle = new int[]{Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MIN_VALUE,Integer.MIN_VALUE};
        for (int[] rectangle : rectangles) {
            int[][]fourPoints = getFourPoints(rectangle);
            totalArea += getArea(rectangle);
            bigRectangle[0] = Math.min(bigRectangle[0],rectangle[0]);
            bigRectangle[1] = Math.min(bigRectangle[1],rectangle[1]);
            bigRectangle[2] = Math.max(bigRectangle[2],rectangle[2]);
            bigRectangle[3] = Math.max(bigRectangle[3],rectangle[3]);
            for (int[] point : fourPoints) {
                String key = hash(point[0],point[1]);
                if (hashMap.containsKey(key)){
                    hashSetSingle.remove(key);
                }else{
                    hashSetSingle.add(key);
                }
                hashMap.put(key,hashMap.getOrDefault(key,0)+1);
            }
        }
        if (hashSetSingle.size() != 4){
            return false;
        }
        if (totalArea != getArea(bigRectangle)){
            return false;
        }
        int[][] bigFourPoints = getFourPoints(bigRectangle);
        for (int[] bigFourPoint : bigFourPoints) {
            if (!hashSetSingle.contains(hash(bigFourPoint[0],bigFourPoint[1]))){
                return false;
            }
        }
        for (String s : hashMap.keySet()) {
            if ( !hashSetSingle.contains(s) && hashMap.get(s)!=2 && hashMap.get(s)!=4 ){
                return false;
            }
        }
        return true;
    }

    private int[][] getFourPoints(int[] rectangle){
        return new int[][]{
                {rectangle[0],rectangle[3]},
                {rectangle[2],rectangle[3]},
                {rectangle[2],rectangle[1]},
                {rectangle[0],rectangle[1]}
        };
    }

    //哈希
    private String hash(int x, int y) {
        return x + "_" + y;
    }

    //面积
    public int getArea(int[] rectangle){
        return ( rectangle[2] - rectangle[0] ) *  ( rectangle[3] - rectangle[1] );
    }


}