这道题是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 <= N <= 10^9
0 <= lamps.length <= 20000
0 <= queries.length <= 20000
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++ 的写法,感觉哈希表真的是一种高效的算法。