Solution is Added By anjha

Author: anjha1

0766.toeplitz-matrix/README.md

@@ -0,0 +1,2 @@
+# [766. Toeplitz Matrix](https://leetcode.com/problems/toeplitz-matrix/)
+

0766.toeplitz-matrix/ToeplitzMatrix.java

@@ -0,0 +1,25 @@
+class ToeplitzMatrix {
+    private boolean check(int[][] matrix, int expectValue, int row, int col) {
+        if (row >= matrix.length || col >= matrix[0].length) {
+            return true;
+        }
+        if (matrix[row][col] != expectValue) {
+            return false;
+        }
+        return check(matrix, expectValue, row + 1, col + 1);
+    }
+
+    public boolean isToeplitzMatrix(int[][] matrix) {
+        for (int i = 0; i < matrix[0].length; i++) {
+            if (!check(matrix, matrix[0][i], 0, i)) {
+                return false;
+            }
+        }
+        for (int i = 1; i < matrix.length; i++) {
+            if (!check(matrix, matrix[i][0], i, 0)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

0769.max-chunks-to-make-sorted/MaxChunksToMakeSorted.java

@@ -0,0 +1,12 @@
+class MaxChunksToMakeSorted {
+    public int maxChunksToSorted(int[] arr) {
+        if (arr == null) return 0;
+        int ret = 0;
+        int right = arr[0];
+        for (int i = 0; i < arr.length; i++) {
+            right = Math.max(right, arr[i]);
+            if (i == right) ret++;
+        }
+        return ret;
+    }
+}

0769.max-chunks-to-make-sorted/README.md

@@ -0,0 +1,2 @@
+# [769. Max Chunks To Make Sorted](https://leetcode.com/problems/max-chunks-to-make-sorted/)
+

0783.minimum-distance-between-bst-nodes/MinimumDistanceBetweenBstNodes.java

@@ -0,0 +1,37 @@
+/**
+ * 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 MinimumDistanceBetweenBstNodes {
+    int ans, pre;
+
+    public int minDiffInBST(TreeNode root) {
+        ans = Integer.MAX_VALUE;
+        pre = -1;
+        dfs(root);
+        return ans;
+    }
+
+    private void dfs(TreeNode root) {
+        if (root == null)
+            return;
+
+        dfs(root.left);
+        if (pre != -1) {
+            ans = Math.min(ans, root.val - pre);
+        }
+        pre = root.val;
+        dfs(root.right);
+    }
+}

0783.minimum-distance-between-bst-nodes/README.md

@@ -0,0 +1,8 @@
+# [783. Minimum Distance Between BST Nodes](https://leetcode.com/problems/minimum-distance-between-bst-nodes/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the nodes of tree.
+- Space Complexity: $O(n)$.

0784.letter-case-permutation/LetterCasePermutation.java

@@ -0,0 +1,30 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class LetterCasePermutation {
+    private void backtrack(char[] str, int pos, List<String> res) {
+        if (pos == str.length) {
+            res.add(new String(str));
+            return;
+        }
+
+        if (Character.isLetter(str[pos])) {
+            if (Character.isUpperCase(str[pos])) {
+                str[pos] = Character.toLowerCase(str[pos]);
+                backtrack(str, pos + 1, res);
+                str[pos] = Character.toUpperCase(str[pos]);
+            } else {
+                str[pos] = Character.toUpperCase(str[pos]);
+                backtrack(str, pos + 1, res);
+                str[pos] = Character.toLowerCase(str[pos]);
+            }
+        }
+        backtrack(str, pos + 1, res);
+    }
+
+    public List<String> letterCasePermutation(String s) {
+        List<String> res = new ArrayList<>();
+        backtrack(s.toCharArray(), 0, res);
+        return res;
+    }
+}

0784.letter-case-permutation/README.md

@@ -0,0 +1 @@
+# [784. Letter Case Permutation](https://leetcode.com/problems/letter-case-permutation/)

0785.is-graph-bipartite/IsGraphBipartite.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+
+class IsGraphBipartite {
+    private boolean isBipartite(int curNode, int curColor, int[] colors, int[][] graph) {
+        if (colors[curNode] != -1) {
+            return colors[curNode] == curColor;
+        }
+        colors[curNode] = curColor;
+        for (int nextNode : graph[curNode]) {
+            if (!isBipartite(nextNode, 1 - curColor, colors, graph)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean isBipartite(int[][] graph) {
+        int[] colors = new int[graph.length];
+        Arrays.fill(colors, -1);
+        for (int i = 0; i < graph.length; i++) {
+            if (colors[i] == -1 && !isBipartite(i, 0, colors, graph)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

0785.is-graph-bipartite/README.md

@@ -0,0 +1,2 @@
+# [785. Is Graph Bipartite?](https://leetcode.com/problems/is-graph-bipartite/)
+

0787.cheapest-flights-within-k-stops/CheapestFlightsWithinKStops.java

@@ -0,0 +1,22 @@
+import java.util.Arrays;
+
+class CheapestFlightsWithinKStops {
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        final int inf = 10000 * 101 + 1;
+        int[][] f = new int[k + 2][n];
+        for (int i = 0; i < k + 2; i++)
+            Arrays.fill(f[i], inf);
+        f[0][src] = 0;
+        for (int t = 1; t <= k + 1; t++) {
+            for (int[] flight : flights) {
+                int j = flight[0], i = flight[1], cost = flight[2];
+                f[t][i] = Math.min(f[t][i], f[t - 1][j] + cost);
+            }
+        }
+        int ans = inf;
+        for (int t = 1; t <= k + 1; t++)
+            ans = Math.min(ans, f[t][dst]);
+
+        return ans == inf ? -1 : ans;
+    }
+}

0787.cheapest-flights-within-k-stops/README.md

@@ -0,0 +1,8 @@
+# [787. Cheapest Flights Within K Stops](https://leetcode.com/problems/cheapest-flights-within-k-stops/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O((m+n)\times k)$. $m$ is the length of `flights`. We first use $O(nk)$ to generate the `f` array, and use $O(mk)$ to iterate all `flights`. Thus, the total time complexity is $O(m+n)\times k)$.
+- Space Complexity: $O(nk)$. The size of `f` is $O(nk)$.

0790.domino-and-tromino-tiling/DominoAndTrominoTiling.java

@@ -0,0 +1,15 @@
+class DominoAndTrominoTiling {
+    static final int modulo = 1000000007;
+
+    public int numTilings(int n) {
+        int[][] dp = new int[n + 1][4];
+        dp[0][3] = 1;
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = dp[i - 1][3];
+            dp[i][1] = (dp[i - 1][0] + dp[i - 1][2]) % modulo;
+            dp[i][2] = (dp[i - 1][0] + dp[i - 1][1]) % modulo;
+            dp[i][3] = (((dp[i - 1][0] + dp[i - 1][1]) % modulo + dp[i - 1][2]) % modulo + dp[i - 1][3]) % modulo;
+        }
+        return dp[n][3];
+    }
+}

0790.domino-and-tromino-tiling/README.md

@@ -0,0 +1,8 @@
+# [790. Domino and Tromino Tiling](https://leetcode.com/problems/domino-and-tromino-tiling/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the total columns.
+- Space Complexity: $O(n)$. We use $4n$ to save DP array, so the space complexity is $O(4n)=O(n)$.

0792.number-of-matching-subsequences/NumberOfMatchingSubsequences.java

@@ -0,0 +1,40 @@
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Queue;
+
+class NumberOfMatchingSubsequences {
+    public int numMatchingSubseq(String s, String[] words) {
+        Map<Character, Queue<String>> map = new HashMap<>();
+        int ans = 0;
+
+        for (int i = 0; i < s.length(); i++) {
+            map.putIfAbsent(s.charAt(i), new LinkedList<>());
+        }
+
+        for (String word : words) {
+            char startChar = word.charAt(0);
+            if (map.containsKey(startChar)) {
+                map.get(startChar).offer(word);
+            }
+        }
+
+        for (int i = 0; i < s.length(); i++) {
+            char startChar = s.charAt(i);
+            Queue<String> q = map.get(startChar);
+            int size = q.size();
+            for (int j = 0; j < size; j++) {
+                String str = q.poll();
+                if (str != null) {
+                    if (str.substring(1).length() == 0) ans++;
+                    else {
+                        if (map.containsKey(str.charAt(1))) {
+                            map.get(str.charAt(1)).add(str.substring(1));
+                        }
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+}

0792.number-of-matching-subsequences/README.md

@@ -0,0 +1,2 @@
+# [792. Number of Matching Subsequences](https://leetcode.com/problems/number-of-matching-subsequences/)
+

0797.all-paths-from-source-to-target/AllPathsFromSourceToTarget.java

@@ -0,0 +1,27 @@
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+
+class AllPathsFromSourceToTarget {
+    List<List<Integer>> ans = new ArrayList<>();
+    Deque<Integer> stack = new ArrayDeque<>();
+
+    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
+        stack.offerLast(0);
+        dfs(graph, 0, graph.length - 1);
+        return ans;
+    }
+
+    private void dfs(int[][] graph, int x, int n) {
+        if (x == n) {
+            ans.add(new ArrayList<>(stack));
+            return;
+        }
+        for (int y : graph[x]) {
+            stack.offerLast(y);
+            dfs(graph, y, n);
+            stack.pollLast();
+        }
+    }
+}

0797.all-paths-from-source-to-target/README.md

@@ -0,0 +1,8 @@
+# [797. All Paths From Source to Target](https://leetcode.com/problems/all-paths-from-source-to-target/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\times 2^n)$. $n$ is the number of nodes. The worst case scenario is every nodes can connect to all the larger nodes. The number of path is $O(2^n)$ and the path is $O(n)$. Thus, the total time complexity is $O(n\times 2^n)$.
+- Space Complexity: $O(n)$. The stack costs $O(n)$.

0804.unique-morse-code-words/README.md

@@ -0,0 +1,2 @@
+# [804. Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words/)
+

0804.unique-morse-code-words/UniqueMorseCodeWords.java

@@ -0,0 +1,21 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class UniqueMorseCodeWords {
+    public int uniqueMorseRepresentations(String[] words) {
+        Set<String> codeSet = new HashSet<>();
+        String[] codes = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
+        int res = 0;
+        for (String word : words) {
+            String morseCode = "";
+            for (char c : word.toCharArray()) {
+                morseCode = morseCode.concat(codes[c - 'a']);
+            }
+            if (!codeSet.contains(morseCode)) {
+                codeSet.add(morseCode);
+                res++;
+            }
+        }
+        return res;
+    }
+}

0814.binary-tree-pruning/BinaryTreePruning.java

@@ -0,0 +1,32 @@
+/**
+ * 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 BinaryTreePruning {
+    private boolean containsOne(TreeNode node) {
+        if (node == null) return false;
+
+        boolean leftContainsOne = containsOne(node.left);
+        boolean rightContainsOne = containsOne(node.right);
+
+        if (!leftContainsOne) node.left = null;
+        if (!rightContainsOne) node.right = null;
+
+        return node.val == 1 || leftContainsOne || rightContainsOne;
+    }
+
+    public TreeNode pruneTree(TreeNode root) {
+        return containsOne(root) ? root : null;
+    }
+}

0814.binary-tree-pruning/README.md

@@ -0,0 +1 @@
+# [814. Binary Tree Pruning](https://leetcode.com/problems/binary-tree-pruning/)