在 N x N 的网格上，每个单元格 (x, y) 上都有一盏灯，其中 0 <= x < N 且 0 <= y < N 。

最初，一定数量的灯是亮着的。lamps[i] 告诉我们亮着的第 i 盏灯的位置。每盏灯都照亮其所在 x 轴、y 轴和两条对角线上的每个正方形（类似于国际象棋中的皇后）。

对于第 i 次查询 queries[i] = (x, y)，如果单元格 (x, y) 是被照亮的，则查询结果为 1，否则为 0 。

在每个查询 (x, y) 之后 [按照查询的顺序]，我们关闭位于单元格 (x, y) 上或其相邻 8 个方向上（与单元格 (x, y) 共享一个角或边）的任何灯。

返回答案数组 answer。每个值 answer[i] 应等于第 i 次查询 queries[i] 的结果。

示例：

输入：N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
输出：[1,0]
解释： 
在执行第一次查询之前，我们位于 [0, 0] 和 [4, 4] 灯是亮着的。
表示哪些单元格亮起的网格如下所示，其中 [0, 0] 位于左上角：
1 1 1 1 1
1 1 0 0 1
1 0 1 0 1
1 0 0 1 1
1 1 1 1 1
然后，由于单元格 [1, 1] 亮着，第一次查询返回 1。在此查询后，位于 [0，0] 处的灯将关闭，网格现在如下所示：
1 0 0 0 1
0 1 0 0 1
0 0 1 0 1
0 0 0 1 1
1 1 1 1 1
在执行第二次查询之前，我们只有 [4, 4] 处的灯亮着。现在，[1, 0] 处的查询返回 0，因为该单元格不再亮着。

提示：

1 <= N <= 10^9
0 <= lamps.length <= 20000
0 <= queries.length <= 20000
lamps[i].length == queries[i].length == 2

思路：

暴力法，统计所有被照亮的点和灯的位置，根据题意写。但是过程中要用哈希表，不然直接定义N*N矩阵会空间超限，四个哈希表分别用到存放点亮的行，列，主副对角线，关灯时候维护四张表。具体实现如下。

class Solution {
public:
    vector<int> gridIllumination(int N, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
        unordered_set<string> reslamp;
        unordered_map<int,int> rm,cm,maindm,vicedm;
        int dx[]={-1,-1,-1,0,0,0,1,1,1};
        int dy[]={-1,0,1,-1,0,1,-1,0,1};
        for(auto lamp:lamps)
        {
            string temp=to_string(lamp[0])+" "+to_string(lamp[1]);
            reslamp.insert(temp);
            rm[lamp[0]]++;
            cm[lamp[1]]++;
            maindm[lamp[0]-lamp[1]]++;
            vicedm[lamp[0]+lamp[1]]++;
        }
        vector<int> res;
        for(auto query:queries)
        {
            int x=query[0];
            int y=query[1];
            //cout<<x<<" "<<y<<endl;
            //cout<<rm[x]<<" "<<cm[y]<<" "<<maindm[x-y]<<" "<<vicedm[x+y]<<endl;
            if(rm[x] || cm[y] || maindm[x-y] || vicedm[x+y])
                res.push_back(1);
            else
                res.push_back(0);
            for(int i=0;i<8;i++)
            {
                if((x+dx[i]>=0 && x+dx[i]<N) || (y+dy[i]>=0 && y+dy[i]<N))
                {
                    string temp=to_string(x+dx[i])+" "+to_string(y+dy[i]);
                    auto it=reslamp.find(temp);
                    if(it==reslamp.end())
                        continue;
                    reslamp.erase(temp);
                    rm[x+dx[i]]--;
                    cm[y+dy[i]]--;
                    maindm[x+dx[i]-(y+dy[i])]--;
                    vicedm[x+dx[i]+(y+dy[i])]--;
                }
            }
            
        }
        return res;
    }
};