Grid Illumination LeetCode solution in Java

1
class Solution {
2
  public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {
3
    // we take 5 hashmap
4
    // 1st hashmap for row
5
    HashMap<Integer, Integer> row = new HashMap<>();
6
    // 2nd hashmap for column
7
    HashMap<Integer, Integer> col = new HashMap<>();
8
    // 3rd hashmap for lower diagonal
9
    HashMap<Integer, Integer> d1 = new HashMap<>();
10
    // 4th diagonal for upper diagonal
11
    HashMap<Integer, Integer> d2 = new HashMap<>();
12
    // 5th diagonal for cell no meaning lamp is present at this spot
13
    HashMap<Integer, Integer> cellno = new HashMap<>();
14

15
    for (int i = 0; i < lamps.length; i++) {
16
      // get row and column from lamps array
17
      int row1 = lamps[i][0];
18
      int col1 = lamps[i][1];
19
      // place row in row hashmap
20
      row.put(row1, row.getOrDefault(row1, 0) + 1);
21
      // place column in col hashmap
22
      col.put(col1, col.getOrDefault(col1, 0) + 1);
23
      // place d1 dia in d1
24
      d1.put((row1 + col1), d1.getOrDefault((row1 + col1), 0) + 1);
25
      // place d2 diagonal
26
      d2.put((row1 - col1), d2.getOrDefault((row1 - col1), 0) + 1);
27
      // place cellno in cell no hashmap
28
      int cell = row1 * n + col1;
29
      cellno.put(cell, cellno.getOrDefault(cell, 0) + 1);
30
    }
31
    // direction array which travels in 8 adjacent direction
32
    int[][] dir = {{-1, 0}, {-1, 1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}};
33
    int[] ans = new int[queries.length];
34
    // process all queries
35
    for (int i = 0; i < queries.length; i++) {
36
      int row1 = queries[i][0];
37
      int col1 = queries[i][1];
38
      int cell = row1 * n + col1;
39
      ans[i] =
40
          (row.containsKey(row1)
41
                  || col.containsKey(col1)
42
                  || d1.containsKey(row1 + col1)
43
                  || d2.containsKey(row1 - col1)
44
                  || cellno.containsKey(cell))
45
              ? 1
46
              : 0;
47
      // if query has a bulb
48
      if (cellno.containsKey(cell)) {
49

50
        int val = cellno.get(cell);
51

52
        cellno.remove(cell);
53

54
        // for row
55
        if (row.containsKey(row1)) {
56
          int rowval = row.get(row1);
57
          rowval -= val;
58
          if (rowval == 0) {
59
            row.remove(row1);
60
          } else {
61
            row.put(row1, rowval);
62
          }
63
        }
64

65
        // for col
66
        if (col.containsKey(col1)) {
67
          int colval = col.get(col1);
68
          colval -= val;
69
          if (colval == 0) {
70
            col.remove(col1);
71
          } else {
72
            col.put(col1, colval);
73
          }
74
        }
75

76
        // for d1
77
        if (d1.containsKey(row1 + col1)) {
78
          int d1val = d1.get(row1 + col1);
79
          d1val -= val;
80
          if (d1val == 0) {
81
            d1.remove(row1 + col1);
82
          } else {
83
            row.put((row1 + col1), d1val);
84
          }
85
        }
86

87
        // for d2
88
        if (d2.containsKey(row1 - col1)) {
89
          int d2val = d2.get(row1 - col1);
90
          d2val -= val;
91
          if (d2val == 0) {
92
            d2.remove(row1 - col1);
93
          } else {
94
            d2.put((row1 - col1), d2val);
95
          }
96
        }
97
      }
98
      // moves all 8 direction and remove the illumination
99
      for (int j = 0; j < dir.length; j++) {
100
        int rowdash = row1 + dir[j][0];
101
        int coldash = col1 + dir[j][1];
102
        int cellno1 = rowdash * n + coldash;
103
        if (cellno.containsKey(cellno1)) {
104
          int val = cellno.get(cellno1);
105

106
          cellno.remove(cellno1);
107

108
          // for row
109
          if (row.containsKey(rowdash)) {
110
            int rowval = row.get(rowdash);
111
            rowval -= val;
112
            if (rowval == 0) {
113
              row.remove(rowdash);
114
            } else {
115
              row.put(rowdash, rowval);
116
            }
117
          }
118

119
          // for col
120
          if (col.containsKey(coldash)) {
121
            int colval = col.get(coldash);
122
            colval -= val;
123
            if (colval == 0) {
124
              col.remove(coldash);
125
            } else {
126
              col.put(coldash, colval);
127
            }
128
          }
129

130
          // for d1
131
          if (d1.containsKey(rowdash + coldash)) {
132
            int d1val = d1.get(rowdash + coldash);
133
            d1val -= val;
134
            if (d1val == 0) {
135
              d1.remove(rowdash + coldash);
136
            } else {
137
              row.put((rowdash + coldash), d1val);
138
            }
139
          }
140

141
          // for d2
142
          if (d2.containsKey(rowdash - coldash)) {
143
            int d2val = d2.get(rowdash - coldash);
144
            d2val -= val;
145
            if (d2val == 0) {
146
              d2.remove(rowdash - coldash);
147
            } else {
148
              d2.put((rowdash - coldash), d2val);
149
            }
150
          }
151
        }
152
      }
153
    }
154

155
    return ans;
156
  }
157
}