Added 3 solutions

varunu28 · varunu28 · commit 16bff8ab06e7 · 2019-07-22T10:22:17.000-07:00
diff --git a/Easy/Number of Equivalent Domino Pairs.java b/Easy/Number of Equivalent Domino Pairs.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int numEquivDominoPairs(int[][] dominoes) {
+        Map<String, Integer> map = new HashMap <>();
+        for (int i = 0; i < dominoes.length; i++) {
+            String key = Math.min(dominoes[i][0], dominoes[i][1]) + "|" + Math.max(dominoes[i][0], dominoes[i][1]);
+            map.put(key, map.getOrDefault(key, 0) + 1);
+        }
+        
+        int count = 0;
+        for (int value : map.values()) {
+            count += (value * (value - 1)) / 2;
+        }
+        
+        return count;
+    }
+}
diff --git a/Easy/Rotting Oranges.java b/Easy/Rotting Oranges.java
@@ -0,0 +1,48 @@
+class Solution {
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    public int orangesRotting(int[][] grid) {
+        Queue<Integer> queue = new LinkedList<>();
+        Map<Integer, Integer> map = new HashMap<>();
+        int numRows = grid.length;
+        int numCols = grid[0].length;
+
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (grid[i][j] == 2) {
+                    int key = numCols * i + j;
+                    queue.add(key);
+                    map.put(key, 0);
+                }
+            }
+        }
+
+        int ans = 0;
+        while (!queue.isEmpty()) {
+            int key = queue.remove();
+            int x = key / numCols;
+            int y = key % numCols;
+            for (int[] dir : dirs) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX < 0 || newX >= numRows || newY < 0 || newY >= numCols || grid[newX][newY] != 1) {
+                    continue;
+                }
+                grid[newX][newY] = 2;
+                int newKey = newX * numCols + newY;
+                queue.add(newKey);
+                map.put(newKey, map.get(key) + 1);
+                ans = map.get(newKey);
+            }
+        }
+
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (grid[i][j] == 1) {
+                    return -1;
+                }
+            }
+        }
+
+        return ans;
+    }
+}
diff --git a/Medium/Walls and Gates.java b/Medium/Walls and Gates.java
@@ -0,0 +1,40 @@
+class Solution {
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    public void wallsAndGates(int[][] rooms) {
+        if (rooms.length == 0 || rooms[0].length == 0) {
+            return;
+        }
+        
+        Queue<Integer> queue = new LinkedList<>();
+        int numRows = rooms.length;
+        int numCols = rooms[0].length;
+        
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (rooms[i][j] == 0) {
+                    int key = i * numCols + j;
+                    queue.add(key);
+                }
+            }
+        }
+        
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            int x = removed / numCols;
+            int y = removed % numCols;
+            
+            for (int[] dir : dirs) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                
+                if (newX < 0 || newX >= numRows || newY < 0 || newY >= numCols || rooms[newX][newY] != 2147483647) {
+                    continue;    
+                }
+                
+                rooms[newX][newY] = rooms[x][y] + 1;
+                int newKey = newX * numCols + newY;
+                queue.add(newKey);
+            }
+        }
+    }
+}
