Merge branch 'master' of https://github.com/BNSC1/leetcode-kotlin

Author: BNSC1

LeetCode/200. Number of Islands.java

@@ -0,0 +1,43 @@
+class Solution {
+    public int numIslands(char[][] g) {
+        int rows = g.length;
+        int cols = g[0].length;
+        int[] DIRS = {1,0,-1,0,1};
+        int res = 0;
+        Set<Pair<Integer, Integer>> visit = new HashSet<>();
+        class Helper {
+            LinkedList<Pair<Integer, Integer>> q = new LinkedList<>();
+            void markOff(Pair<Integer, Integer> coord) {
+                q.add(coord);
+                while (!q.isEmpty()) {
+                    Pair<Integer, Integer> popCoord = q.poll();
+                    int popR = popCoord.getKey();
+                    int popC = popCoord.getValue();
+                    for (int i=0; i<DIRS.length-1; i++) {
+                        int newR = DIRS[i] + popR;
+                        int newC = DIRS[i + 1] + popC;
+                        Pair<Integer, Integer> newCoord = new Pair<>(newR, newC);
+                        if (newR >= 0 && newR < rows &&
+                            newC >= 0 && newC < cols &&
+                            g[newR][newC] == '1' &&
+                            !visit.contains(newCoord)) {
+                                visit.add(newCoord);
+                                q.add(newCoord);
+                            }
+                    }
+                }
+            }
+        }
+        Helper helper = new Helper();
+        for (int r=0; r<rows; r++) {
+            for (int c=0; c<cols; c++) {
+                Pair<Integer, Integer> coord = new Pair<>(r, c);
+                if (g[r][c] == '1' && !visit.contains(coord)) {
+                    helper.markOff(coord);
+                    res++;
+                }
+            }
+        }
+        return res;
+    }
+}

LeetCode/33. Search in Rotated Sorted Array.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        int size = nums.length;
+        int start = 0;
+        int end = size - 1;
+        while (start <= end) {
+            int mid = (end + start) / 2;
+            if (nums[mid] == target) return mid;
+            if (nums[start] > nums[mid]) {
+                if (target > nums[end] ||
+                    target < nums[mid]) end = mid - 1;
+                else start = mid + 1;
+            } else {
+                if (target < nums[start] ||
+                    target > nums[mid]) start = mid + 1;
+                else end = mid - 1;
+            }
+        }
+
+        return -1;
+    }
+} //TC: O(logn), SC: O(1)

LeetCode/39. Combination Sum.java

@@ -0,0 +1,17 @@
+class Solution {
+    public List<List<Integer>> combinationSum(int[] cands, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        class Helper {
+            void backtrack(int i, List<Integer> cur, int diff) {
+                if (diff == 0) res.add(new ArrayList<>(cur));
+                if (i >= cands.length || diff <= 0) return;
+                cur.add(cands[i]);
+                backtrack(i, cur, diff - cands[i]);
+                cur.remove(cur.size() - 1);
+                backtrack(i + 1, cur, diff);
+            }
+        }
+        new Helper().backtrack(0, new ArrayList<>(), target);
+        return res;
+    }
+} //TC: O(N^(M/T + 1)), SC: O(T/M), where T is the target value, N is the number of candidates, M is the smallest candidate among all the given integers

LeetCode/98. Validate Binary Search Tree.java

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        LinkedList<TreeNode> st = new LinkedList<>();
+        TreeNode cur = root;
+        TreeNode small = null;
+        while (cur != null || !st.isEmpty()) {
+            while (cur != null) {
+                st.push(cur);
+                cur = cur.left;
+            }
+            cur = st.poll();
+            if (small != null && cur.val <= small.val) return false;
+            small = cur;
+            cur = cur.right;
+        }
+        return true;
+    }
+} //TC: O(n), SC: O(height of tree), where n is node count

LeetCode/994. Rotting Oranges.java

@@ -0,0 +1,46 @@
+class Solution {
+    public int orangesRotting(int[][] g) {
+        int[] DIRS = {1, 0, -1, 0, 1};
+        int rows = g.length;
+        int cols = g[0].length;
+
+        int res = 0;
+        int fresh = 0;
+        LinkedList<Pair<Integer,Integer>> q = new LinkedList<>();
+        
+        for (int r=0; r<rows; r++) {
+            for (int c=0; c<cols; c++) {
+                Pair<Integer,Integer> coord = new Pair<>(r, c);
+                if (g[r][c] == 2) {
+                    q.add(coord);
+                } else if (g[r][c] == 1) fresh++;
+            }
+        }
+
+        while (!q.isEmpty() && fresh > 0) {
+            int size = q.size();
+            for (int i=0; i<size; i++) {
+                Pair<Integer,Integer> coord = q.poll();
+                int r = coord.getKey();
+                int c = coord.getValue();
+
+                for (int d=0; d<DIRS.length-1; d++) {
+                    int nr = r + DIRS[d];
+                    int nc = c + DIRS[d + 1];
+                    Pair<Integer,Integer> newCoord = new Pair<>(nr, nc);
+                    if (nr >= 0 && nr < rows &&
+                        nc >= 0 && nc < cols &&
+                        g[nr][nc] == 1) {
+                        q.add(newCoord);
+                        g[nr][nc] = 2;
+                        fresh--;
+                    }
+                }
+            }
+            res++;
+        }
+
+        if (fresh > 0) return -1;
+        return res;
+    }
+}