leetcode----1001.网格照明（模拟+哈希表）

1001.网格照明（模拟+哈希表）

问题：在大小为 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 表示未照亮。

示例：

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

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

思路：若这道题使用二维数组来模拟的话，则会超时。参考三水小姐姐的题解

所以使用了5个哈希表来存储打开的灯以及被照亮的灯的位置信息。分别表示被打开的灯所在的行、列、左对角线、右对角线以及自身（打开的灯）的位置。 使用二维转一维的方式记录自身的坐标：使用 x * n + y来表示(x, y)

注意：1、同一盏打开的灯不会将 所在行列以及对角线上的灯照亮两次。2、要关闭的是打开的灯，不是被照亮的灯

class Solution {
    int[][] dirs = new int[][]{{0,0},{0,-1},{0,1},{-1,0},{-1,-1},{-1,1},{1,0},{1,-1},{1,1}};
    public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {
        long N = n;
        //代表打开的灯所在行与列上的灯被照亮了
        Map<Integer, Integer> row = new HashMap<>(), col = new HashMap<>();
        //使用截距表示打开的灯所在两条对角线上的灯被照亮了
        Map<Integer, Integer> left = new HashMap<>(), right = new HashMap<>();
        //表示被打开的灯的坐标信息，二维转一维：使用 x * n + y来表示(x, y)
        Set<Long> cur = new HashSet<>();

        for(int[] lamp: lamps){
            int x = lamp[0], y = lamp[1];
            int l = x + y, r = x - y;
            long c = x * N + y;
            //这里应该去重，同一盏灯不会将另外的灯照亮两次
            if(cur.contains(c)) continue;
            increment(row, x);
            increment(col, y);
            increment(left, l);
            increment(right, r);
            cur.add(c);
        }

        int len = queries.length;
        int[] res = new int[len];
        for(int i = 0; i < len; i++){
            int x = queries[i][0], y = queries[i][1];
            int l = x + y, r = x - y;
            long c = x * N + y;
            if(row.containsKey(x) || col.containsKey(y) || left.containsKey(l) || right.containsKey(r) || cur.contains(c)){
                res[i] = 1;
            }

			//关闭当前灯相邻八个方向中打开的灯
            for(int[] dir: dirs){
                int nx = x + dir[0], ny = y + dir[1];
                int nl = nx + ny, nr = nx - ny;
                long nc = nx * N + ny;
                //检查数组越界
                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
                //要关闭的是打开的灯，不是被照亮的灯
                if(cur.contains(nc)){
                    decrement(row, nx);
                    decrement(col, ny);
                    decrement(left, nl);
                    decrement(right, nr);
                    cur.remove(nc);
                }
            }
        }
        return res;
    }

    private void increment(Map<Integer, Integer> map, int k){
        map.put(k, map.getOrDefault(k, 0) + 1);
    }

    private void decrement(Map<Integer, Integer> map, int k){
        if(map.get(k) == 1){
            map.remove(k);
        } else {
            map.put(k, map.get(k) - 1);
        }
    }
}

整理思路，记录博客，以便复习。若有误，望指正~