【LeetCode】Grid Illumination(网格照明)

这道题是LeetCode里的第1001道题。

题目要求：

在 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. 1 <= N <= 10^9
2. 0 <= lamps.length <= 20000
3. 0 <= queries.length <= 20000
4. lamps[i].length == queries[i].length == 2

这道题和N皇后问题很像，如果有读者做过与N皇后类似的题且能够熟练使用哈希表，这道题就会迎刃而解，我本人做过N皇后的题目，但不会使用哈希表，通过这次做题，我基本了解了哈希表的使用方法。

好了话不多说，先说说解题思路吧：

最最最重要的是对于每一个要查询的点 (x,y)，即为 queries[k][0] 和 queries[k][1]，要计算这个点是否有灯光照射到这里，也就是说对于这个点它的上下左右两条线都不能有灯，并且正斜线和逆斜线这两条线上也不能有灯，上下左右很好判断，就是在 lamp 灯中遍历它的 x,y 的值。但是如何去确定斜线方向上的位置是否有灯呢？这就需要基本的数学知识，画图去理解了。

如图，红线是正斜线，线上的点 (x,y) 永远满足 x-y=k(k是定值)，黑线逆斜线同理。所以如果要判断所求点 (x,y) 和某一个灯是否在同一斜线上只要去计算他们 x+y 的值或是 x-y 的值是否相等，就行了。代码如下：

解题代码：

C++ 使用的是 vector：

class Solution {
public:
    vector<int> gridIllumination(int N, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
        vector<int>res;
        int light[lamps.size()]={0};//定义一个数组来查询等是否关闭，0代表开，1代表关
        //for(int i=0;i<lamps.size();i++)
        //    cout<<light[i]<<endl;
        int state;//保存查询的点是亮的还是不亮的的状态
        for(int i=0;i<queries.size();i++){
            state=0;
            long long qx=queries[i][0];//为了保证不会数据溢出
            long long qy=queries[i][1];
            for(int j=0;j<lamps.size();j++){
                if(light[j]==1)continue;//如果灯关了，就不用继续判断
                long long lx=lamps[j][0];//为了保证不会数据溢出
                long long ly=lamps[j][1];
                if(qx==lx||qy==ly||qx-qy==lx-ly||qx+qy==lx+ly){
                    state=1;
                    if((abs((qx-lx))<=1||abs((qy-ly))<=1)&&//保证不会超时
                       (qx-lx)*(qx-lx)+(qy-ly)*(qy-ly)<=2)
                        light[j]=1;//把四周离点距离小于等于根号2的灯关闭
                }
            }
            res.push_back(state);
        }
        return res;
    }
};

Java 使用的是哈希表：

import java.util.Map;
import java.util.Set;
import java.util.HashMap;
import java.util.HashSet;

class Solution {
    private static Map<Integer,Set<String>>lamp_X;
    private static Map<Integer,Set<String>>lamp_Y;
    private static Map<Integer,Set<String>>lamp_P;
    private static Map<Integer,Set<String>>lamp_R;

	public static int[] gridIllumination(int N, int[][] lamps, int[][] queries) {
		int[]res = new int[queries.length];
		initialization(lamps);

		for(int i = 0;i < queries.length;i++) {
			int X = queries[i][0];
			int Y = queries[i][1];

			int state = isLight(X,Y)?1:0;
			res[i] = state;
			if(state == 1) {//依次关灯
				turnOff(X,Y);
				turnOff(X-1,Y);
				turnOff(X+1,Y);
				turnOff(X,Y+1);
				turnOff(X,Y-1);
				turnOff(X-1,Y+1);
				turnOff(X+1,Y+1);
				turnOff(X-1,Y-1);
				turnOff(X+1,Y-1);
			}
		}
		return res;
	}

	public static void turnOff(int X,int Y) {
		int P = X + Y;
		int R = X - Y;

		StringBuilder sb = new StringBuilder();
		sb.append(X).append(',').append(Y);
		//关灯
		if(lamp_X.containsKey(X)) {
			lamp_X.get(X).remove(sb.toString());
		}
		if(lamp_Y.containsKey(Y)) {
			lamp_Y.get(Y).remove(sb.toString());
		}
		if(lamp_P.containsKey(P)) {
			lamp_P.get(P).remove(sb.toString());
		}
		if(lamp_R.containsKey(R)) {
			lamp_R.get(R).remove(sb.toString());
		}
	}

	public static boolean isLight(int X,int Y) {
		int P = X + Y;
		int R = X - Y;
		//判断是否有灯，就是看是否有键，而且要满足键有一个非空集合的映射
		if(lamp_X.containsKey(X) && !lamp_X.get(X).isEmpty())
			return true;
		if(lamp_Y.containsKey(Y) && !lamp_Y.get(Y).isEmpty())
			return true;
		if(lamp_P.containsKey(P) && !lamp_P.get(P).isEmpty())
			return true;
		if(lamp_R.containsKey(R) && !lamp_R.get(R).isEmpty())
			return true;
		return false;
	}

	public static void initialization(int[][] lamps) {
		lamp_X = new HashMap<>();    //横向
		lamp_Y = new HashMap<>();    //纵向
		lamp_P = new HashMap<>();    //正斜向
		lamp_R = new HashMap<>();    //逆斜向
		StringBuilder sb = new StringBuilder();

		for(int[] i : lamps) {
			int X = i[0];
			int Y = i[1];
			int P = X + Y;
			int R = X - Y;
			//首先要知道是否有X的键，没有则需要创建一个映射
			if(!lamp_X.containsKey(X)) {
				lamp_X.put(X, new HashSet<>());
			}
			if(!lamp_Y.containsKey(Y)) {
				lamp_Y.put(Y, new HashSet<>());
			}
			if(!lamp_P.containsKey(P)) {
				lamp_P.put(P, new HashSet<>());
			}
			if(!lamp_R.containsKey(R)) {
				lamp_R.put(R, new HashSet<>());
			}

			sb.setLength(0);//这里相当于初始化，清除上一次的点位
			sb.append(X).append(',').append(Y);
			//加入集合中
			lamp_X.get(X).add(sb.toString());
			lamp_Y.get(Y).add(sb.toString());
			lamp_P.get(P).add(sb.toString());
			lamp_R.get(R).add(sb.toString());
		}
	}
}

提交结果：

C++的结果：

Java的结果：

个人总结：

通过本次解题的过程，我对 Java 的 Map,Set,HashMap,HashSet 接口和类都有了一定的了解，同时也复习了一下 C++ 的写法，感觉哈希表真的是一种高效的算法。