All Downloads are FREE. Search and download functionalities are using the official Maven repository.

g1001_1100.s1001_grid_illumination.Solution Maven / Gradle / Ivy

There is a newer version: 1.38
Show newest version
package g1001_1100.s1001_grid_illumination;

// #Hard #Array #Hash_Table #2023_04_26_Time_82_ms_(89.13%)_Space_57.5_MB_(89.13%)

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

/**
 * 1001 - Grid Illumination\.
 *
 * Hard
 *
 * There is a 2D `grid` of size `n x n` where each cell of this grid has a lamp that is initially **turned off**.
 *
 * You are given a 2D array of lamp positions `lamps`, where lamps[i] = [rowi, coli] indicates that the lamp at grid[rowi][coli] is **turned on**. Even if the same lamp is listed more than once, it is turned on.
 *
 * When a lamp is turned on, it **illuminates its cell** and **all other cells** in the same **row, column, or diagonal**.
 *
 * You are also given another 2D array `queries`, where queries[j] = [rowj, colj]. For the jth query, determine whether grid[rowj][colj] is illuminated or not. After answering the jth query, **turn off** the lamp at grid[rowj][colj] and its **8 adjacent lamps** if they exist. A lamp is adjacent if its cell shares either a side or corner with grid[rowj][colj].
 *
 * Return _an array of integers_ `ans`_,_ _where_ `ans[j]` _should be_ `1` _if the cell in the_ jth _query was illuminated, or_ `0` _if the lamp was not._
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2020/08/19/illu_1.jpg)
 *
 * **Input:** n = 5, lamps = \[\[0,0],[4,4]], queries = \[\[1,1],[1,0]]
 *
 * **Output:** [1,0]
 *
 * **Explanation:** We have the initial grid with all lamps turned off. In the above picture we see the grid after turning on the lamp at grid[0][0] then turning on the lamp at grid[4][4]. The 0th query asks if the lamp at grid[1][1] is illuminated or not (the blue square). It is illuminated, so set ans[0] = 1. Then, we turn off all lamps in the red square. ![](https://assets.leetcode.com/uploads/2020/08/19/illu_step1.jpg) The 1st query asks if the lamp at grid[1][0] is illuminated or not (the blue square). It is not illuminated, so set ans[1] = 0. Then, we turn off all lamps in the red rectangle. ![](https://assets.leetcode.com/uploads/2020/08/19/illu_step2.jpg)
 *
 * **Example 2:**
 *
 * **Input:** n = 5, lamps = \[\[0,0],[4,4]], queries = \[\[1,1],[1,1]]
 *
 * **Output:** [1,1]
 *
 * **Example 3:**
 *
 * **Input:** n = 5, lamps = \[\[0,0],[0,4]], queries = \[\[0,4],[0,1],[1,4]]
 *
 * **Output:** [1,1,0]
 *
 * **Constraints:**
 *
 * *   1 <= n <= 109
 * *   `0 <= lamps.length <= 20000`
 * *   `0 <= queries.length <= 20000`
 * *   `lamps[i].length == 2`
 * *   0 <= rowi, coli < n
 * *   `queries[j].length == 2`
 * *   0 <= rowj, colj < n
**/
public class Solution {
    public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {
        Map rowIlluminations = new HashMap<>();
        Map colIlluminations = new HashMap<>();
        Map posDiagIlluminations = new HashMap<>();
        Map negDiagIlluminations = new HashMap<>();
        Set lampPlacements = new HashSet<>();
        for (int[] lamp : lamps) {
            int row = lamp[0];
            int col = lamp[1];
            long key = row;
            key = key * n + col;
            if (lampPlacements.contains(key)) {
                continue;
            }
            incr(rowIlluminations, row);
            incr(colIlluminations, col);
            incr(posDiagIlluminations, row + col);
            incr(negDiagIlluminations, row + (n - 1 - col));
            lampPlacements.add(key);
        }
        int[] ans = new int[queries.length];
        for (int i = 0; i < ans.length; i++) {
            int row = queries[i][0];
            int col = queries[i][1];
            if (rowIlluminations.containsKey(row)
                    || colIlluminations.containsKey(col)
                    || posDiagIlluminations.containsKey(row + col)
                    || negDiagIlluminations.containsKey(row + (n - 1 - col))) {
                ans[i] = 1;
            }
            int topRow = Math.max(0, row - 1);
            int bottomRow = Math.min(n - 1, row + 1);
            int leftCol = Math.max(0, col - 1);
            int rightCol = Math.min(n - 1, col + 1);
            for (int r = topRow; r <= bottomRow; r++) {
                for (int c = leftCol; c <= rightCol; c++) {
                    long key = r;
                    key = key * n + c;
                    if (lampPlacements.contains(key)) {
                        decr(rowIlluminations, r);
                        decr(colIlluminations, c);
                        decr(posDiagIlluminations, r + c);
                        decr(negDiagIlluminations, r + (n - 1 - c));
                        lampPlacements.remove(key);
                    }
                }
            }
        }
        return ans;
    }

    private void incr(Map map, int key) {
        map.put(key, map.getOrDefault(key, 0) + 1);
    }

    private void decr(Map map, int key) {
        int v = map.get(key);
        if (map.get(key) == 1) {
            map.remove(key);
        } else {
            map.put(key, v - 1);
        }
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy