在大小为 n x n 的网格 grid 上，每个单元格都有一盏灯，最初灯都处于 关闭 状态。

    给你一个由灯的位置组成的二维数组 lamps ，其中 lamps[i] = [rowi, coli] 表示 打开 位于 grid[rowi][coli] 的灯。即便同一盏灯可能在 lamps 中多次列出，不会影响这盏灯处于 打开 状态。

    当一盏灯处于打开状态，它将会照亮 自身所在单元格 以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格 。

    另给你一个二维数组 queries ，其中 queries[j] = [rowj, colj] 。对于第 j 个查询，如果单元格 [rowj, colj] 是被照亮的，则查询结果为 1 ，否则为 0 。在第 j 次查询之后 [按照查询的顺序] ，关闭 位于单元格 grid[rowj][colj] 上及相邻 8 个方向上（与单元格 grid[rowi][coli] 共享角或边）的任何灯。

    返回一个整数数组 ans 作为答案， ans[j] 应等于第 j 次查询 queries[j] 的结果，1 表示照亮，0 表示未照亮。

    示例 1：
    image.png

    输入：n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
    输出：[1,0]
    解释：最初所有灯都是关闭的。在执行查询之前，打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮（蓝色方框）。该单元格被照亮，所以 ans[0] = 1 。然后，关闭红色方框中的所有灯。

    第 1 次查询检查 grid[1][0] 是否被照亮（蓝色方框）。该单元格没有被照亮，所以 ans[1] = 0 。然后，关闭红色矩形中的所有灯。

    示例 2：

    输入：n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]
    输出：[1,1]
    示例 3：

    输入：n = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]]
    输出：[1,1,0]

    提示：

    1 <= n <= 109
    0 <= lamps.length <= 20000
    0 <= queries.length <= 20000
    lamps[i].length == 2
    0 <= rowi, coli < n
    queries[j].length == 2
    0 <= rowj, colj < n

    1. class Solution {
    2.     int[][] dirs = new int[][]{{0,0},{0,-1},{0,1},{-1,0},{-1,-1},{-1,1},{1,0},{1,-1},{1,1}};
    3.     public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {
    4.         Long N = (long)n;
    5.         //四个方向上的map存储点对应的亮暗
    6.         Map<Integer,Integer> row = new HashMap(), col = new HashMap();
    7.         Map<Integer,Integer> left = new HashMap(), right = new HashMap();
    8.         Set<Long> set = new HashSet<>();
    9.         for (int[] lamp : lamps) {
    10.             int a = lamp[0], b = lamp[1];
    11.             int x = a + b, y = a - b;
    12.             //判重
    13.             if (set.contains(a * N + b)) continue;
    14.             increment(row,a); increment(col,b);
    15.             increment(left,x); increment(right,y);
    16.             set.add(a * N + b);
    17.         }
    18.         int[] res = new int[queries.length];
    19.         for (int i = 0; i < queries.length; ++i) {
    20.             int x = queries[i][0], y = queries[i][1];
    21.             int a = x + y, b = x - y;
    22.             //判断是否点亮
    23.             if (row.containsKey(x) || col.containsKey(y) || left.containsKey(a) || right.containsKey(b)) res[i] = 1;
    25.             for (int[] dir : dirs) {
    26.                 int nx = x + dir[0], ny = y + dir[1];
    27.                 int na = nx + ny, nb = nx - ny;
    28.                 if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;
    29.                 if (set.contains(nx * N + ny)) {
    30.                     set.remove(nx * N + ny);
    31.                     decrement(row,nx); decrement(col,ny);
    32.                     decrement(left,na); decrement(right,nb);
    33.                 }
    34.             }
    35.         }
    36.         return res;
    37.     }
    38.     private void increment(Map<Integer,Integer> map, int x) {
    39.         map.put(x,map.getOrDefault(x,0) + 1);
    40.     }
    41.     private void decrement(Map<Integer,Integer> map, int x) {
    42.         if (map.get(x) == 1) map.remove(x);
    43.         else map.put(x,map.get(x)-1);
    44.     }
    45. }