Solution is Added

Author: anjha1

0820.short-encoding-of-words/README.md

@@ -0,0 +1,2 @@
+# [820. Short Encoding of Words](https://leetcode.com/problems/short-encoding-of-words/)
+

0820.short-encoding-of-words/ShortEncodingOfWords.java

@@ -0,0 +1,20 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+class ShortEncodingOfWords {
+    public int minimumLengthEncoding(String[] words) {
+        Set<String> wordSet = new HashSet<>(Arrays.asList(words));
+        for (String s : words) {
+            for (int i = 1; i < s.length(); i++) {
+                wordSet.remove(s.substring(i));
+            }
+        }
+
+        int length = 0;
+        for (String s : wordSet) {
+            length += s.length() + 1;
+        }
+        return length;
+    }
+}

0823.binary-trees-with-factors/BinaryTreesWithFactors.java

@@ -0,0 +1,31 @@
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+class BinaryTreesWithFactors {
+    private final int mod = (int) (Math.pow(10, 9) + 7);
+
+    public int numFactoredBinaryTrees(int[] arr) {
+        if (arr.length == 0) return 0;
+
+        Arrays.sort(arr);
+        Map<Integer, Long> map = new HashMap<>();
+
+        for (int i = 0; i < arr.length; i++) {
+            long count = 1L;
+            for (int j = 0; j < i; j++) {
+                if (arr[i] % arr[j] == 0 && map.containsKey(arr[i] / arr[j])) {
+                    count += map.get(arr[j]) * map.get(arr[i] / arr[j]);
+                }
+            }
+            map.put(arr[i], count);
+        }
+
+        long totalCount = 0L;
+        for (Map.Entry<Integer, Long> entry : map.entrySet()) {
+            totalCount += entry.getValue();
+        }
+
+        return (int) (totalCount % mod);
+    }
+}

0823.binary-trees-with-factors/README.md

@@ -0,0 +1,2 @@
+# [823. Binary Trees With Factors](https://leetcode.com/problems/binary-trees-with-factors/)
+

0834.sum-of-distances-in-tree/README.md

@@ -0,0 +1,8 @@
+# [834. Sum of Distances in Tree](https://leetcode.com/problems/sum-of-distances-in-tree/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the number of tree nodes. We only need to traverse nodes twice to get the answer, so the time complexity is $O(2n)=O(n)$.
+- Space Complexity: $O(n)$. We have three arrays, dp, size and ans. The space complexity is $O(3n)=O(n)$.

0834.sum-of-distances-in-tree/SumOfDistancesInTree.java

@@ -0,0 +1,55 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class SumOfDistancesInTree {
+    int[] ans, size, dp;
+    List<List<Integer>> graph;
+
+    public int[] sumOfDistancesInTree(int n, int[][] edges) {
+        ans = new int[n];
+        size = new int[n];
+        dp = new int[n];
+        graph = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            graph.add(new ArrayList<>());
+        for (int[] edge : edges) {
+            graph.get(edge[0]).add(edge[1]);
+            graph.get(edge[1]).add(edge[0]);
+        }
+        dfs(0, -1);
+        dfs2(0, -1);
+        return ans;
+    }
+
+    public void dfs(int u, int f) {
+        size[u] = 1;
+        dp[u] = 0;
+        for (int v : graph.get(u)) {
+            if (v == f) continue;
+            dfs(v, u);
+            dp[u] += dp[v] + size[v];
+            size[u] += size[v];
+        }
+    }
+
+    public void dfs2(int u, int f) {
+        ans[u] = dp[u];
+        for (int v : graph.get(u)) {
+            if (v == f) continue;
+            int parentU = dp[u], parentV = dp[v];
+            int childU = size[u], childV = size[v];
+
+            dp[u] -= dp[v] + size[v];
+            size[u] -= size[v];
+            dp[v] += dp[u] + size[u];
+            size[v] += size[u];
+
+            dfs2(v, u);
+
+            dp[u] = parentU;
+            dp[v] = parentV;
+            size[u] = childU;
+            size[v] = childV;
+        }
+    }
+}

0835.image-overlap/ImageOverlap.java

@@ -0,0 +1,29 @@
+class ImageOverlap {
+    private int shiftAndCount(int xShift, int yShift, int[][] matrix, int[][] reference) {
+        int leftShiftCount = 0, rightShiftCount = 0;
+        int rRow = 0;
+        for (int mRow = yShift; mRow < matrix.length; mRow++) {
+            int rCol = 0;
+            for (int mCol = xShift; mCol < matrix.length; mCol++) {
+                if (matrix[mRow][mCol] == 1 && matrix[mRow][mCol] == reference[rRow][rCol])
+                    leftShiftCount += 1;
+                if (matrix[mRow][rCol] == 1 && matrix[mRow][rCol] == reference[rRow][mCol])
+                    rightShiftCount += 1;
+                rCol += 1;
+            }
+            rRow += 1;
+        }
+        return Math.max(leftShiftCount, rightShiftCount);
+    }
+
+    public int largestOverlap(int[][] img1, int[][] img2) {
+        int maxOverlaps = 0;
+        for (int yShift = 0; yShift < img1.length; yShift++) {
+            for (int xShift = 0; xShift < img1.length; xShift++) {
+                maxOverlaps = Math.max(maxOverlaps, shiftAndCount(xShift, yShift, img1, img2));
+                maxOverlaps = Math.max(maxOverlaps, shiftAndCount(xShift, yShift, img2, img1));
+            }
+        }
+        return maxOverlaps;
+    }
+}

0835.image-overlap/README.md

@@ -0,0 +1,2 @@
+# [835. Image Overlap](https://leetcode.com/problems/image-overlap/)
+

0838.push-dominoes/PushDominoes.java

@@ -0,0 +1,36 @@
+class PushDominoes {
+    public String pushDominoes(String dominoes) {
+        int n = dominoes.length();
+        int[] indexes = new int[n + 2];
+        char[] symbols = new char[n + 2];
+        int len = 1;
+        indexes[0] = -1;
+        symbols[0] = 'L';
+
+        for (int i = 0; i < n; i++) {
+            if (dominoes.charAt(i) != '.') {
+                indexes[len] = i;
+                symbols[len++] = dominoes.charAt(i);
+            }
+        }
+
+        indexes[len] = n;
+        symbols[len++] = 'R';
+
+        char[] res = dominoes.toCharArray();
+        for (int index = 0; index < len - 1; index++) {
+            int i = indexes[index], j = indexes[index + 1];
+            char x = symbols[index], y = symbols[index + 1];
+            if (x == y) {
+                for (int k = i + 1; k < j; k++) {
+                    res[k] = x;
+                }
+            } else if (x > y) {
+                for (int k = i + 1; k < j; k++) {
+                    res[k] = k - i == j - k ? '.' : k - i < j - k ? 'R' : 'L';
+                }
+            }
+        }
+        return String.valueOf(res);
+    }
+}

0838.push-dominoes/README.md

@@ -0,0 +1,2 @@
+# [838. Push Dominoes](https://leetcode.com/problems/push-dominoes/)
+

0841.keys-and-rooms/KeysAndRooms.java

@@ -0,0 +1,24 @@
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class KeysAndRooms {
+    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
+        int n = rooms.size(), num = 0;
+        boolean[] visited = new boolean[n];
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(0);
+        visited[0] = true;
+        while (!queue.isEmpty()) {
+            int roomNumber = queue.poll();
+            num++;
+            for (int key : rooms.get(roomNumber)) {
+                if (!visited[key]) {
+                    visited[key] = true;
+                    queue.offer(key);
+                }
+            }
+        }
+        return num == n;
+    }
+}

0841.keys-and-rooms/README.md

@@ -0,0 +1,7 @@
+# [841. Keys and Rooms](https://leetcode.com/problems/keys-and-rooms/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n+m)$. $n$ is the room number and $m$ is the number of the keys in all rooms.
+- Space Complexity: $O(n)$. We used $n$ which is the number of room for the stack of recursion.

0844.backspace-string-compare/BackspaceStringCompare.java

@@ -0,0 +1,30 @@
+import java.util.Stack;
+
+class BackspaceStringCompare {
+    private String filterString(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            stack.push(c);
+        }
+        StringBuilder res = new StringBuilder();
+        int popCount = 0;
+        while (!stack.isEmpty()) {
+            if (stack.peek() == '#') {
+                popCount++;
+                stack.pop();
+            } else if (popCount != 0) {
+                stack.pop();
+                popCount--;
+            } else {
+                res.append(stack.pop());
+            }
+        }
+        return res.toString();
+    }
+
+    public boolean backspaceCompare(String s, String t) {
+        String newS = filterString(s);
+        String newT = filterString(t);
+        return newS.equals(newT);
+    }
+}

0844.backspace-string-compare/README.md

@@ -0,0 +1,2 @@
+# [844. Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/)
+

0858.mirror-reflection/MirrorReflection.java

@@ -0,0 +1,11 @@
+class MirrorReflection {
+    public int mirrorReflection(int p, int q) {
+        while (p % 2 == 0 && q % 2 == 0) {
+            p /= 2;
+            q /= 2;
+        }
+        if (p % 2 == 0) return 2;
+        if (q % 2 == 0) return 0;
+        return 1;
+    }
+}

0858.mirror-reflection/README.md

@@ -0,0 +1 @@
+# [858. Mirror Reflection](https://leetcode.com/problems/mirror-reflection/)

0869.reordered-power-of-2/README.md

@@ -0,0 +1,2 @@
+# [869. Reordered Power of 2](https://leetcode.com/problems/reordered-power-of-2/)
+

0869.reordered-power-of-2/ReorderedPowerOf2.java

@@ -0,0 +1,22 @@
+import java.util.Arrays;
+
+class ReorderedPowerOf2 {
+    private int[] count(int n) {
+        int[] res = new int[10];
+        while (n > 0) {
+            res[n % 10]++;
+            n /= 10;
+        }
+        return res;
+    }
+
+    public boolean reorderedPowerOf2(int n) {
+        int[] arrays = count(n);
+        for (int i = 0; i < 31; i++) {
+            if (Arrays.equals(arrays, count(1 << i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

0871.minimum-number-of-refueling-stops/MinimumNumberOfRefuelingStops.java

@@ -0,0 +1,18 @@
+class MinimumNumberOfRefuelingStops {
+    public int minRefuelStops(int target, int startFuel, int[][] stations) {
+        long[] dp = new long[stations.length + 1];
+        dp[0] = startFuel;
+
+        for (int i = 0; i < stations.length; i++) {
+            for (int refill = i; refill >= 0 && dp[refill] >= stations[i][0]; refill--) {
+                dp[refill + 1] = Math.max(dp[refill + 1], dp[refill] + stations[i][1]);
+            }
+        }
+
+        for (int i = 0; i <= stations.length; i++) {
+            if (dp[i] >= target) return i;
+        }
+
+        return -1;
+    }
+}

0871.minimum-number-of-refueling-stops/README.md

@@ -0,0 +1,2 @@
+# [871. Minimum Number of Refueling Stops](https://leetcode.com/problems/minimum-number-of-refueling-stops/)
+

0872.leaf-similar-trees/LeafSimilarTrees.java

@@ -0,0 +1,42 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 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 LeafSimilarTrees {
+    private void dfs(TreeNode root, List<Integer> seq) {
+        if (root.left == null && root.right == null)
+            seq.add(root.val);
+        else {
+            if (root.left != null)
+                dfs(root.left, seq);
+            if (root.right != null)
+                dfs(root.right, seq);
+        }
+    }
+
+    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+        List<Integer> seq1 = new ArrayList<>();
+        if (root1 != null)
+            dfs(root1, seq1);
+
+        List<Integer> seq2 = new ArrayList<>();
+        if (root2 != null)
+            dfs(root2, seq2);
+
+        return seq1.equals(seq2);
+    }
+}

0872.leaf-similar-trees/README.md

@@ -0,0 +1,8 @@
+# [872. Leaf-Similar Trees](https://leetcode.com/problems/leaf-similar-trees/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n_1+n_2)$. $n_1$ and $n_2$ are the number of nodes in the two trees respectively.
+- Space Complexity: $O(n_1+n_2)$. Space complexity depends on the stack size of the recursion.