LeetCode-1001 网格照明

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/grid-illumination

题目描述

在大小为 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：

输入：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 <= 10⁹
0 <= lamps.length <= 20000
0 <= queries.length <= 20000
lamps[i].length == 2
0 <= rowi, coli < n
queries[j].length == 2
0 <= rowj, colj < n

解题思路

看题目难度hard和样本规模10⁹基本就放弃了暴力模拟的方法。这道题有两个难点，一个是灯是如何表示亮暗，一个是位置亮暗如何判断。

首先由于n的规模巨大，所以我们不可能用n*n的矩阵来存储每一个灯的状态，所以我们仅仅只能记录亮着的灯的位置，而由于要频繁的查询和删除晾着的灯，我们使用一个set来表示亮着的灯，将二维坐标转换为一维坐标，使用row * n + col 来表示灯的一维坐标。这里有个坑点就是由于row和col的最大值很大，所以row*n+col可能超出int的最大表示范围，所以转换为long long。

再来考虑如何判断查询点是否亮暗，使用四个map做哈希表来分别存储亮暗的状态，使用row来存储行亮的状态，row的键就是代表行数，值代表此行有几盏亮着的灯。col的键代表列数，值代表此行有几盏亮着的等。left表示左上到右下的对角线，它的键是表示对角线与竖边界的交点的行数，也就是row - col 值代表着此对角线有几盏两者的灯，right和left对角线类似。这样我们就可以将整个网格的亮的状态用这四个哈希表表示出来，查询是时候也只需要查询查询点所在行列对角线是否有亮着的灯就好了。需要注意的是，在亮灯的数据中有重复打开同一盏灯的操作，需要排除。

查询结束后，根据查询点将九个位置的灯灭掉，更新四个哈希表的值即可，在灭九个位置灯的过程中，要考虑坐标是否已经超出网格边界。

代码展示

class Solution {
public:
    vector<int> gridIllumination(int n, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
        vector<int> viRet;
        set<long long> setiLamps;
        unordered_map<int, int> mapiiRow, mapiiCol, mapiiLeft, mapiiRight;
        for(auto iter: lamps)
        {
            long long temp = (long long)iter[0] * n + iter[1];
            auto setIter = setiLamps.find(temp);
            if(setIter == setiLamps.end())
            {
                setiLamps.insert(temp);
                mapiiRow[iter[0]]++;
                mapiiCol[iter[1]]++;
                mapiiLeft[iter[0] - iter[1]]++;
                mapiiRight[iter[0] + iter[1]]++;
            }
        }
        for(auto iter: queries)
        {
            if(mapiiRow[iter[0]] || mapiiCol[iter[1]] || mapiiLeft[iter[0] - iter[1]] || mapiiRight[iter[0] + iter[1]])
            {
                viRet.push_back(1);
            }
            else
            {
                viRet.push_back(0);
            }
            for(int i = -1; i < 2; i++)
            {
                for(int j = -1; j < 2; j++)
                {
                    int iRow = iter[0] + i, iCol = iter[1] + j;
                    if(iRow < 0 || iRow >= n || iCol < 0 || iCol >= n)
                        continue;
                    long long temp = (long long)iRow * n + iCol;
                    auto setIter = setiLamps.find(temp);
                    if(setIter != setiLamps.end())
                    {
                        mapiiRow[iRow]--;
                        mapiiCol[iCol]--;
                        mapiiLeft[iRow - iCol]--;
                        mapiiRight[iRow + iCol]--;
                        setiLamps.erase(setIter);
                    }
                }
            }
        }
        return viRet;
    }
};

运行结果