Added tasks 1977, 1979, 1980, 1981, 1982.

Author: ThanhNIT

src/main/java/g1901_2000/s1977_number_of_ways_to_separate_numbers/Solution.java

@@ -0,0 +1,240 @@
+package g1901_2000.s1977_number_of_ways_to_separate_numbers;
+
+// #Hard #String #Dynamic_Programming #Suffix_Array
+// #2022_05_21_Time_150_ms_(94.52%)_Space_101.1_MB_(90.41%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private static final int P = 1_000_000_007;
+
+    public int numberOfCombinations(String num) {
+        int n = num.length();
+        if (num.charAt(0) == '0') {
+            return 0;
+        }
+        if (n == 1) {
+            return 1;
+        }
+
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = num.charAt(i) - '0' + 1;
+        }
+
+        int[] suffixArray = new SuffixArrayTools().buildSuffixArray(arr);
+        int[] invSuffixArray = new SuffixArrayTools().inverseSuffixArray(suffixArray);
+        int[] lcp =
+                SuffixArrayTools.buildLongestCommonPrefixArray(arr, suffixArray, invSuffixArray);
+        int[][] lcpMat = new int[n - 1][n - 1];
+        for (int i = 0; i < n - 1; i++) {
+            lcpMat[i][i] = lcp[i];
+        }
+        for (int i = 0; i < n - 2; i++) {
+            for (int j = i + 1; j < n - 1; j++) {
+                lcpMat[i][j] = Math.min(lcpMat[i][j - 1], lcpMat[j][j]);
+            }
+        }
+
+        long[] prev = new long[n + 1];
+        long[] next = new long[n + 1];
+        long[] tmp;
+        prev[0] = 1;
+        next[0] = 1;
+
+        for (int d = 1; d <= n; d++) {
+            System.arraycopy(prev, 1, next, 1, n);
+            for (int j1 = 0, i1 = j1 - d, j2 = j1 + d; j2 <= n; j1++, j2++, i1++) {
+                if (arr[j1] != 1) {
+                    if (i1 < 0 || arr[i1] != 1 && ok(i1, j1, d, invSuffixArray, lcpMat)) {
+                        next[j2] += next[j1];
+                    } else {
+                        next[j2] += prev[j1];
+                    }
+                    if (next[j2] >= P) {
+                        next[j2] -= P;
+                    }
+                }
+            }
+            tmp = prev;
+            prev = next;
+            next = tmp;
+        }
+        return (int) prev[n];
+    }
+
+    private boolean ok(int start1, int start2, int len, int[] inv, int[][] lcpMat) {
+        return inv[start1] < inv[start2] || lcpMat[inv[start2]][inv[start1] - 1] >= len;
+    }
+
+    static class SuffixArrayTools {
+        int[] buildSuffixArray(int[] arr) {
+            int n = arr.length;
+            int[] s = Arrays.copyOf(arr, n + 3);
+            int[] sa = new int[n];
+            suffixArray(s, sa, n, 10);
+            return sa;
+        }
+
+        private int[] inverseSuffixArray(int[] suffixArray) {
+            int n = suffixArray.length;
+            int[] ans = new int[n];
+            for (int i = 0; i < n; i++) {
+                ans[suffixArray[i]] = i;
+            }
+            return ans;
+        }
+
+        static int[] buildLongestCommonPrefixArray(
+                int[] arr, int[] suffixArray, int[] invSuffixArray) {
+            int n = arr.length;
+            int[] lcp = new int[n - 1];
+            int k = 0;
+            for (int i = 0; i < n; i++) {
+                if (k > 0) {
+                    k--;
+                }
+                if (invSuffixArray[i] == n - 1) {
+                    k = 0;
+                } else {
+                    int j = suffixArray[invSuffixArray[i] + 1];
+                    while (i + k < n && j + k < n && arr[i + k] == arr[j + k]) {
+                        k++;
+                    }
+                    lcp[invSuffixArray[i]] = k;
+                }
+            }
+            return lcp;
+        }
+
+        private boolean leq(int a1, int a2, int b1, int b2) {
+            return (a1 < b1 || (a1 == b1 && a2 <= b2));
+        }
+
+        private boolean leq(int a1, int a2, int a3, int b1, int b2, int b3) {
+            return (a1 < b1 || (a1 == b1 && leq(a2, a3, b2, b3)));
+        }
+
+        private void suffixArray(int[] s, int[] sa, int n, int k) {
+            int n0 = (n + 2) / 3;
+            int n1 = (n + 1) / 3;
+            int n2 = n / 3;
+            int n02 = n0 + n2;
+            int[] s12 = new int[n02 + 3];
+            int[] sa12 = new int[n02 + 3];
+            int[] s0 = new int[n0];
+            int[] sa0 = new int[n0];
+            int i = 0;
+            int j = 0;
+            while (i < n + (n0 - n1)) {
+                if (i % 3 != 0) {
+                    s12[j++] = i;
+                }
+                i++;
+            }
+
+            radixPass(s12, sa12, s, 2, n02, k);
+            radixPass(sa12, s12, s, 1, n02, k);
+            radixPass(s12, sa12, s, 0, n02, k);
+
+            int name = 0;
+            int c0 = -1;
+            int c1 = -1;
+            int c2 = -1;
+            for (i = 0; i < n02; i++) {
+                if (s[sa12[i]] != c0 || s[sa12[i] + 1] != c1 || s[sa12[i] + 2] != c2) {
+                    name++;
+                    c0 = s[sa12[i]];
+                    c1 = s[sa12[i] + 1];
+                    c2 = s[sa12[i] + 2];
+                }
+                if (sa12[i] % 3 == 1) {
+                    s12[sa12[i] / 3] = name;
+                } else {
+                    s12[sa12[i] / 3 + n0] = name;
+                }
+            }
+
+            if (name < n02) {
+                suffixArray(s12, sa12, n02, name);
+                for (i = 0; i < n02; i++) {
+                    s12[sa12[i]] = i + 1;
+                }
+            } else {
+                for (i = 0; i < n02; i++) {
+                    sa12[s12[i] - 1] = i;
+                }
+            }
+            i = 0;
+            j = 0;
+            while (i < n02) {
+                if (sa12[i] < n0) {
+                    s0[j++] = 3 * sa12[i];
+                }
+                i++;
+            }
+            radixPass(s0, sa0, s, 0, n0, k);
+            int p = 0;
+            int t = n0 - n1;
+            int i1 = 0;
+            while (i1 < n) {
+                i = getI(sa12, n0, t);
+                j = sa0[p];
+                if (sa12[t] < n0
+                        ? leq(s[i], s12[sa12[t] + n0], s[j], s12[j / 3])
+                        : leq(
+                                s[i],
+                                s[i + 1],
+                                s12[sa12[t] - n0 + 1],
+                                s[j],
+                                s[j + 1],
+                                s12[j / 3 + n0])) {
+                    sa[i1] = i;
+                    t++;
+                    if (t == n02) {
+                        i1++;
+                        while (p < n0) {
+                            sa[i1] = sa0[p];
+                            p++;
+                            i1++;
+                        }
+                    }
+                } else {
+                    sa[i1] = j;
+                    p++;
+                    if (p == n0) {
+                        i1++;
+                        while (t < n02) {
+                            sa[i1] = getI(sa12, n0, t);
+                            t++;
+                            i1++;
+                        }
+                    }
+                }
+                i1++;
+            }
+        }
+
+        private int getI(int[] sa12, int n0, int t) {
+            return sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2;
+        }
+
+        private void radixPass(int[] a, int[] b, int[] r, int shift, int n, int k) {
+            int[] c = new int[k + 1];
+            for (int i = 0; i < n; i++) {
+                c[r[a[i] + shift]]++;
+            }
+            int i = 0;
+            int sum = 0;
+            while (i <= k) {
+                int t = c[i];
+                c[i] = sum;
+                sum += t;
+                i++;
+            }
+            for (i = 0; i < n; i++) {
+                b[c[r[a[i] + shift]]++] = a[i];
+            }
+        }
+    }
+}

src/main/java/g1901_2000/s1977_number_of_ways_to_separate_numbers/readme.md

@@ -0,0 +1,36 @@
+1977\. Number of Ways to Separate Numbers
+
+Hard
+
+You wrote down many **positive** integers in a string called `num`. However, you realized that you forgot to add commas to seperate the different numbers. You remember that the list of integers was **non-decreasing** and that **no** integer had leading zeros.
+
+Return _the **number of possible lists of integers** that you could have written down to get the string_ `num`. Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** num = "327"
+
+**Output:** 2
+
+**Explanation:** You could have written down the numbers: 3, 27 327
+
+**Example 2:**
+
+**Input:** num = "094"
+
+**Output:** 0
+
+**Explanation:** No numbers can have leading zeros and all numbers must be positive.
+
+**Example 3:**
+
+**Input:** num = "0"
+
+**Output:** 0
+
+**Explanation:** No numbers can have leading zeros and all numbers must be positive.
+
+**Constraints:**
+
+*   `1 <= num.length <= 3500`
+*   `num` consists of digits `'0'` through `'9'`.

src/main/java/g1901_2000/s1979_find_greatest_common_divisor_of_array/Solution.java

@@ -0,0 +1,16 @@
+package g1901_2000.s1979_find_greatest_common_divisor_of_array;
+
+// #Easy #Array #Math #Number_Theory #2022_05_21_Time_5_ms_(10.46%)_Space_43.6_MB_(61.12%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int findGCD(int[] nums) {
+        Arrays.sort(nums);
+        return getGcd(nums[0], nums[nums.length - 1]);
+    }
+
+    private int getGcd(int a, int b) {
+        return b == 0 ? a : getGcd(b, a % b);
+    }
+}

src/main/java/g1901_2000/s1979_find_greatest_common_divisor_of_array/readme.md

@@ -0,0 +1,54 @@
+1979\. Find Greatest Common Divisor of Array
+
+Easy
+
+Given an integer array `nums`, return _the **greatest common divisor** of the smallest number and largest number in_ `nums`.
+
+The **greatest common divisor** of two numbers is the largest positive integer that evenly divides both numbers.
+
+**Example 1:**
+
+**Input:** nums = [2,5,6,9,10]
+
+**Output:** 2
+
+**Explanation:** 
+
+The smallest number in nums is 2. 
+
+The largest number in nums is 10. 
+
+The greatest common divisor of 2 and 10 is 2.
+
+**Example 2:**
+
+**Input:** nums = [7,5,6,8,3]
+
+**Output:** 1
+
+**Explanation:** 
+
+The smallest number in nums is 3. 
+
+The largest number in nums is 8. 
+
+The greatest common divisor of 3 and 8 is 1.
+
+**Example 3:**
+
+**Input:** nums = [3,3]
+
+**Output:** 3
+
+**Explanation:** 
+
+The smallest number in nums is 3. 
+
+The largest number in nums is 3. 
+
+The greatest common divisor of 3 and 3 is 3.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 1000`

src/main/java/g1901_2000/s1980_find_unique_binary_string/Solution.java

@@ -0,0 +1,36 @@
+package g1901_2000.s1980_find_unique_binary_string;
+
+// #Medium #Array #String #Backtracking #2022_05_21_Time_7_ms_(31.88%)_Space_42_MB_(59.01%)
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public String findDifferentBinaryString(String[] nums) {
+        Set<String> set = new HashSet<>(Arrays.asList(nums));
+        int len = nums[0].length();
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        while (i < len) {
+            sb.append(1);
+            i++;
+        }
+        int max = Integer.parseInt(sb.toString(), 2);
+        for (int num = 0; num <= max; num++) {
+            String binary = Integer.toBinaryString(num);
+            if (binary.length() < len) {
+                sb.setLength(0);
+                sb.append(binary);
+                while (sb.length() < len) {
+                    sb.insert(0, "0");
+                }
+                binary = sb.toString();
+            }
+            if (!set.contains(binary)) {
+                return binary;
+            }
+        }
+        return null;
+    }
+}