leeetcode 1001. Grid Illumination

On a N x N grid of cells, each cell (x, y) with 0 <= x < N and 0 <= y < N has a lamp.

Initially, some number of lamps are on.  lamps[i] tells us the location of the i-th lamp that is on.  Each lamp that is on illuminates every square on its x-axis, y-axis, and both diagonals (similar to a Queen in chess).

For the i-th query queries[i] = (x, y), the answer to the query is 1 if the cell (x, y) is illuminated, else 0.

After each query (x, y) [in the order given by queries], we turn off any lamps that are at cell (x, y) or are adjacent 8-directionally (ie., share a corner or edge with cell (x, y).)

Return an array of answers.  Each value answer[i] should be equal to the answer of the i-th query queries[i].

 

Example 1:

Input: N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
Output: [1,0]
Explanation: 
Before performing the first query we have both lamps [0,0] and [4,4] on.
The grid representing which cells are lit looks like this, where [0,0] is the top left corner, and [4,4] is the bottom right corner:
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
Then the query at [1, 1] returns 1 because the cell is lit.  After this query, the lamp at [0, 0] turns off, and the grid now looks like this:
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
Before performing the second query we have only the lamp [4,4] on.  Now the query at [1,0] returns 0, because the cell is no longer lit.

 

Note:

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

解题思路：

设置一个set> lampset，  存放每个灯的{x ， y} ；

设置unordered_map xbright , ybright , posi_diag , nega_diag ;

xbright[x]=cnt : 有cnt盏灯使横坐标为x的那一列亮

ybright[y] = cnt ： 有cnt盏灯使纵坐标为y的那一行亮

posi_diag[x - y] = cnt ; 有cnt盏灯使{x , y}的正对角线亮 ；

nega_diag[x + y] = cnt : 有cnt盏灯使{x , y}的反对角线亮 ；

对于queries中的每一个{x , y} ，找其同一行同一列，正对角线，反对角线是否是亮的，只要一条线亮，那这个位置就是亮的 ；

if(xbright.count(x) || ybright.count(y) || posi_diag.count(x - y) || nega_diag.count(x + y)) res[i] = 1 ;

然后查找包括自身和周围8个方向上是否有灯，如果有灯，则从lampset中删掉灯 ， 并将相应行，列和对角线上的灯数-1 ；

class Solution {
public:
    vector gridIllumination(int N, vector>& lamps, vector>& queries) 
    {
        set> lampset ;
        unordered_map xbright , ybright , posi_diag , nega_diag ;
        vector res(queries.size() , 0) ;
        
        for(int i = 0 ; i < lamps.size() ; ++i)
        {
            lampset.insert({lamps[i][0] , lamps[i][1]}) ;
            xbright[lamps[i][0]]++ ;
            ybright[lamps[i][1]]++ ;
            posi_diag[lamps[i][0] - lamps[i][1]]++ ;
            nega_diag[lamps[i][0] + lamps[i][1]]++ ;
        }   

        for(int i = 0 ; i < queries.size() ; i++)
        {
            int x = queries[i][0] , y = queries[i][1] ;
            if(xbright.count(x) || ybright.count(y) || posi_diag.count(x - y) || nega_diag.count(x + y)) res[i] = 1 ;
            
            for(int j = 0 ; j < 9 ; ++j)
            {
                int new_x = x + dir[j][0] , new_y = y + dir[j][1] ;
                if(lampset.count({new_x , new_y}))
                {
                    lampset.erase({new_x , new_y}) ;
                    
                    xbright[new_x]-- ;
                    if(xbright[new_x] == 0) xbright.erase(new_x) ;
                    
                    ybright[new_y]-- ;
                    if(ybright[new_y] == 0) ybright.erase(new_y) ;
                    
                    posi_diag[new_x - new_y]-- ;
                    if(posi_diag[new_x - new_y] == 0) posi_diag.erase(new_x - new_y) ;
                    
                    nega_diag[new_x + new_y]-- ;
                    if(nega_diag[new_x + new_y] == 0) nega_diag.erase(new_x + new_y) ;
                }
            }
        }
        
        return res ;
    }
    
private:
    
    vector> dir = {{0 , 0} ,{0 , 1} , {1 , 1} , {1 , 0} , {1 , -1} , {0 , -1} , {-1 , -1} , {-1 , 0} , {-1 , 1}} ;
};