Code Added

Author: anjha1

1047.remove-all-adjacent-duplicates-in-string/README.md

@@ -0,0 +1,2 @@
+# [1047. Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)
+

1047.remove-all-adjacent-duplicates-in-string/RemoveAllAdjacentDuplicatesInString.java

@@ -0,0 +1,18 @@
+import java.util.Stack;
+
+class RemoveAllAdjacentDuplicatesInString {
+    public String removeDuplicates(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && stack.peek() == c) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder res = new StringBuilder();
+        for (char c : stack)
+            res.append(c);
+        return res.toString();
+    }
+}

1061.lexicographically-smallest-equivalent-string/LexicographicallySmallestEquivalentString.java

@@ -0,0 +1,46 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class LexicographicallySmallestEquivalentString {
+    int minChar;
+
+    public String smallestEquivalentString(String s1, String s2, String baseStr) {
+        int[][] adjMatrix = new int[26][26];
+        for (int i = 0; i < s1.length(); i++) {
+            adjMatrix[s1.charAt(i) - 'a'][s2.charAt(i) - 'a'] = 1;
+            adjMatrix[s2.charAt(i) - 'a'][s1.charAt(i) - 'a'] = 1;
+        }
+
+        int[] mappingChar = new int[26];
+        for (int i = 0; i < 26; i++)
+            mappingChar[i] = i;
+
+        boolean[] visited = new boolean[26];
+        for (int c = 0; c < 26; c++) {
+            if (!visited[c]) {
+                List<Integer> component = new ArrayList<>();
+                minChar = 27;
+                dfs(c, adjMatrix, visited, component);
+                for (int vertex : component)
+                    mappingChar[vertex] = minChar;
+            }
+        }
+
+        StringBuilder ans = new StringBuilder();
+        for (char c : baseStr.toCharArray())
+            ans.append((char) (mappingChar[c - 'a'] + 'a'));
+
+        return ans.toString();
+    }
+
+    private void dfs(int src, int[][] adjMatrix, boolean[] visited, List<Integer> component) {
+        visited[src] = true;
+        component.add(src);
+        minChar = Math.min(minChar, src);
+
+        for (int i = 0; i < 26; i++) {
+            if (adjMatrix[src][i] != 0 && !visited[i])
+                dfs(i, adjMatrix, visited, component);
+        }
+    }
+}

1061.lexicographically-smallest-equivalent-string/README.md

@@ -0,0 +1,7 @@
+# [1061. Lexicographically Smallest Equivalent String](https://leetcode.com/problems/lexicographically-smallest-equivalent-string/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n+m+|\Sigma|^2)$. $n$ is the length of str1 and str2 and $m$ is the length of baseStr. Also, $|\Sigma|$ is the number of unique characters. The total time complexity is $O(n+m+|\Sigma|^2)$.
+- Space Complexity: $O(|\Sigma|^2)$. The DFS recursion costs $O(|\Sigma|^2)$ in maximum.

1071.greatest-common-divisor-of-strings/GreatestCommonDivisorOfStrings.java

@@ -0,0 +1,16 @@
+class GreatestCommonDivisorOfStrings {
+    public String gcdOfStrings(String str1, String str2) {
+        int n1 = str1.length(), n2 = str2.length();
+        for (int i = Math.min(n1, n2); i >= 1; i--) {
+            String x = str1.substring(0, i);
+            if (check(x, str1) && check(x, str2))
+                return x;
+        }
+        return "";
+    }
+
+    private boolean check(String t, String s) {
+        int n = s.length() / t.length();
+        return t.repeat(n).equals(s);
+    }
+}

1071.greatest-common-divisor-of-strings/README.md

@@ -0,0 +1,2 @@
+# [1071. Greatest Common Divisor of Strings](https://leetcode.com/problems/greatest-common-divisor-of-strings/)
+

1074.number-of-submatrices-that-sum-to-target/NumberOfSubmatricesThatSumToTarget.java

@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class NumberOfSubmatricesThatSumToTarget {
+    public int numSubmatrixSumTarget(int[][] matrix, int target) {
+        int row = matrix.length, col = matrix[0].length;
+
+        for (int i = 0; i < row; i++) {
+            for (int j = 1; j < col; j++) {
+                matrix[i][j] += matrix[i][j - 1];
+            }
+        }
+
+        int count = 0;
+
+        for (int c1 = 0; c1 < col; c1++) {
+            for (int c2 = c1; c2 < col; c2++) {
+                Map<Integer, Integer> map = new HashMap<>();
+                map.put(0, 1);
+                int sum = 0;
+
+                for (int[] ints : matrix) {
+                    sum += ints[c2] - (c1 > 0 ? ints[c1 - 1] : 0);
+                    count += map.getOrDefault(sum - target, 0);
+                    map.put(sum, map.getOrDefault(sum, 0) + 1);
+                }
+            }
+        }
+
+        return count;
+    }
+}

1074.number-of-submatrices-that-sum-to-target/README.md

@@ -0,0 +1 @@
+# [1074. Number of Submatrices That Sum to Target](https://leetcode.com/problems/number-of-submatrices-that-sum-to-target/)

1091.shortest-path-in-binary-matrix/README.md

@@ -0,0 +1 @@
+# [1091. Shortest Path in Binary Matrix](https://leetcode.com/problems/shortest-path-in-binary-matrix/)

1091.shortest-path-in-binary-matrix/ShortestPathInBinaryMatrix.java

@@ -0,0 +1,38 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+class ShortestPathInBinaryMatrix {
+    public int shortestPathBinaryMatrix(int[][] grid) {
+        if (grid == null || grid.length == 0 || grid[0].length == 0) return -1;
+        int res = 0;
+
+        int row = grid.length;
+        int col = grid[0].length;
+
+        if (grid[0][0] == 1 || grid[row - 1][col - 1] == 1) return -1;
+        int[][] directions = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
+        boolean[][] visited = new boolean[row][col];
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[]{0, 0});
+        visited[0][0] = true;
+
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            res++;
+
+            for (int i = 0; i < size; i++) {
+                int[] curPos = queue.poll();
+                if (curPos[0] == row - 1 && curPos[1] == col - 1) return res;
+                for (int[] dir : directions) {
+                    int nextX = curPos[0] + dir[0];
+                    int nextY = curPos[1] + dir[1];
+                    if (nextX < 0 || nextX >= row || nextY < 0 || nextY >= col || visited[nextX][nextY] || grid[nextX][nextY] == 1) continue;
+                    visited[nextX][nextY] = true;
+                    queue.offer(new int[]{nextX, nextY});
+                }
+            }
+        }
+
+        return -1;
+    }
+}

1137.n-th-tribonacci-number/NThTribonacciNumber.java

@@ -0,0 +1,14 @@
+class NThTribonacciNumber {
+    public int tribonacci(int n) {
+        if (n == 0) return 0;
+        if (n <= 2) return 1;
+        int first = 0, second = 1, third = 1;
+        for (int i = 3; i <= n; i++) {
+            int temp = first + second + third;
+            first = second;
+            second = third;
+            third = temp;
+        }
+        return third;
+    }
+}

1137.n-th-tribonacci-number/README.md

@@ -0,0 +1,7 @@
+# [1137. N-th Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$.
+- Space Complexity: $O(1)$.

1143.longest-common-subsequence/LongestCommonSubsequence.java

@@ -0,0 +1,17 @@
+class LongestCommonSubsequence {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int m = text1.length(), n = text2.length();
+        int[][] dp = new int[m + 1][n + 1];
+        for (int i = 1; i <= m; i++) {
+            char c1 = text1.charAt(i - 1);
+            for (int j = 1; j <= n; j++) {
+                char c2 = text2.charAt(j - 1);
+                if (c1 == c2)
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                else
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+        return dp[m][n];
+    }
+}

1143.longest-common-subsequence/README.md

@@ -0,0 +1,7 @@
+# [1143. Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(mn)$. $m$ and $n$ are the length of text1 and text2 respectively.
+- Space Complexity: $O(mn)$. we created an array for DP and the space complexity is $O(mn)$.

1155.number-of-dice-rolls-with-target-sum/NumberOfDiceRollsWithTargetSum.java

@@ -0,0 +1,19 @@
+class NumberOfDiceRollsWithTargetSum {
+    private final int modulo = (int) (Math.pow(10, 9) + 7);
+
+    public int numRollsToTarget(int n, int k, int target) {
+        int[][] dp = new int[n + 1][target + 1];
+        dp[0][0] = 1;
+
+        for (int dice = 1; dice <= n; dice++) {
+            for (int targetVal = 0; targetVal <= target; targetVal++) {
+                for (int faceVal = 1; faceVal <= k; faceVal++) {
+                    if (targetVal >= faceVal) {
+                        dp[dice][targetVal] = (dp[dice][targetVal] + dp[dice - 1][targetVal - faceVal]) % modulo;
+                    }
+                }
+            }
+        }
+        return dp[n][target];
+    }
+}

1155.number-of-dice-rolls-with-target-sum/README.md

@@ -0,0 +1,2 @@
+# [1155. Number of Dice Rolls With Target Sum](https://leetcode.com/problems/number-of-dice-rolls-with-target-sum/)
+

1207.unique-number-of-occurrences/README.md

@@ -0,0 +1,7 @@
+# [1207. Unique Number of Occurrences](https://leetcode.com/problems/unique-number-of-occurrences/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. Iterate all elements and save to frequency array is $O(n)$. Suppose the limitation of number range is $2k$. Sort operation is $O(2k\log^{2k})$. Thus, the total time complexity is $O(n+k\log^k)$ which $n$ is the input length and $k=1000$.
+- Space Complexity: $O(k)$. The frequency array is $O(2k)$.

1207.unique-number-of-occurrences/UniqueNumberOfOccurrences.java

@@ -0,0 +1,17 @@
+import java.util.Arrays;
+
+class UniqueNumberOfOccurrences {
+    public boolean uniqueOccurrences(int[] arr) {
+        int[] freq = new int[2001];
+        for (int i = 0; i < arr.length; i++) {
+            freq[arr[i] + 1000]++;
+        }
+        Arrays.sort(freq);
+
+        for (int i = 0; i < 2000; i++) {
+            if (freq[i] != 0 && freq[i] == freq[i + 1])
+                return false;
+        }
+        return true;
+    }
+}

1220.count-vowels-permutation/CountVowelsPermutation.java

@@ -0,0 +1,22 @@
+import java.util.Arrays;
+
+class CountVowelsPermutation {
+    private final int mod = (int) (Math.pow(10, 9) + 7);
+
+    public int countVowelPermutation(int n) {
+        long[][] dp = new long[n+1][5];
+        Arrays.fill(dp[1], 1);
+
+        // a = 0, e = 1, i = 2, o = 3, u = 4
+        for (int i = 2; i < n + 1; i++) {
+            Arrays.fill(dp[i], 0);
+            dp[i][0] = (dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][4]) % mod;
+            dp[i][1] = (dp[i - 1][0] + dp[i - 1][2]) % mod;
+            dp[i][2] = (dp[i - 1][1] + dp[i - 1][3]) % mod;
+            dp[i][3] = dp[i - 1][2];
+            dp[i][4] = (dp[i - 1][2] + dp[i - 1][3]) % mod;
+        }
+
+        return (int) (Arrays.stream(dp[n]).sum() % mod);
+    }
+}

1220.count-vowels-permutation/README.md

@@ -0,0 +1 @@
+# [1220. Count Vowels Permutation](https://leetcode.com/problems/count-vowels-permutation/)