Solutions updated 3516-3519

Author: trinhminhtriet

solutions/3500-3599/3516.find-closest-person/Solution.java

@@ -0,0 +1,8 @@
+class Solution {
+    public int findClosest(int x, int y, int z) {
+        int dis1 = Math.abs(x - z), dis2 = Math.abs(y - z);
+        if (dis1 == dis2)
+            return 0;
+        return dis1 > dis2 ? 2 : 1;
+    }
+}

solutions/3500-3599/3517.smallest-palindromic-rearrangement-i/Solution.java

@@ -0,0 +1,23 @@
+import java.util.Arrays;
+
+class Solution {
+    public String smallestPalindrome(String s) {
+        int n = s.length();
+        int m = n / 2;
+
+        if (n == 1 || n == 2)
+            return s;
+
+        char[] fArr = s.substring(0, m).toCharArray();
+        Arrays.sort(fArr);
+        String f = new String(fArr);
+
+        StringBuilder rev = new StringBuilder(f).reverse();
+
+        if (n % 2 == 1) {
+            f += s.charAt(m);
+        }
+
+        return f + rev.toString();
+    }
+}

solutions/3500-3599/3518.smallest-palindromic-rearrangement-ii/Solution.java

@@ -0,0 +1,84 @@
+class Solution {
+    public String smallestPalindrome(String inputStr, int K) {
+        int[] frequency = new int[26];
+        for (int i = 0; i < inputStr.length(); i++) {
+            char ch = inputStr.charAt(i);
+            frequency[ch - 'a']++;
+        }
+        char mid = 0;
+        for (int i = 0; i < 26; i++) {
+            if (frequency[i] % 2 == 1) {
+                mid = (char) ('a' + i);
+                frequency[i]--;
+                break;
+            }
+        }
+        int[] halfFreq = new int[26];
+        int halfLength = 0;
+        for (int i = 0; i < 26; i++) {
+            halfFreq[i] = frequency[i] / 2;
+            halfLength += halfFreq[i];
+        }
+        long totalPerms = multinomial(halfFreq);
+        if (K > totalPerms)
+            return "";
+        StringBuilder firstHalfBuilder = new StringBuilder();
+        for (int pos = 0; pos < halfLength; pos++) {
+            for (int c = 0; c < 26; c++) {
+                if (halfFreq[c] > 0) {
+                    halfFreq[c]--;
+                    long perms = multinomial(halfFreq);
+                    if (perms >= K) {
+                        firstHalfBuilder.append((char) ('a' + c));
+                        break;
+                    } else {
+                        K -= perms;
+                        halfFreq[c]++;
+                    }
+                }
+            }
+        }
+        String firstHalf = firstHalfBuilder.toString();
+        String revHalf = new StringBuilder(firstHalf).reverse().toString();
+        String result;
+        if (mid == 0) {
+            result = firstHalf + revHalf;
+        } else {
+            String midStr = new String(new char[] { mid });
+            result = firstHalf + midStr + revHalf;
+        }
+        return result;
+    }
+
+    static long maxK = 1000001;
+
+    public long multinomial(int[] counts) {
+        int tot = 0;
+        for (int cnt : counts) {
+            tot += cnt;
+        }
+        long res = 1;
+        for (int i = 0; i < 26; i++) {
+            int cnt = counts[i];
+            res = res * binom(tot, cnt);
+            if (res >= maxK)
+                return maxK;
+            tot -= cnt;
+        }
+        return res;
+    }
+
+    public long binom(int n, int k) {
+        if (k > n)
+            return 0;
+        if (k > n - k)
+            k = n - k;
+        long result = 1;
+        for (int i = 1; i <= k; i++) {
+            result = result * (n - i + 1) / i;
+            if (result >= maxK)
+                return maxK;
+        }
+        return result;
+    }
+}

solutions/3500-3599/3519.count-numbers-with-non-decreasing-digits/Solution.java

@@ -0,0 +1,63 @@
+import java.util.HashMap;
+
+public class Solution {
+    final int MOD = 1000000007;
+    int base;
+    int[] digits;
+    HashMap<String, Integer> memo;
+
+    public int countNumbers(String l, String r, int b) {
+        base = b;
+        int fr = f(r);
+        int fl = l.equals("0") ? 0 : f(new java.math.BigInteger(l).subtract(java.math.BigInteger.ONE).toString());
+        return (fr - fl + MOD) % MOD;
+    }
+
+    private int f(String x) {
+        digits = dec2base(new java.math.BigInteger(x), base);
+        memo = new HashMap<>();
+        return dp(0, -1, true, false);
+    }
+
+    private int[] dec2base(java.math.BigInteger num, int base) {
+        if (num.equals(java.math.BigInteger.ZERO))
+            return new int[] { 0 };
+        ArrayList<Integer> list = new ArrayList<>();
+        while (num.compareTo(java.math.BigInteger.ZERO) > 0) {
+            list.add(num.mod(java.math.BigInteger.valueOf(base)).intValue());
+            num = num.divide(java.math.BigInteger.valueOf(base));
+        }
+        Collections.reverse(list);
+        return list.stream().mapToInt(i -> i).toArray();
+    }
+
+    private int dp(int i, int last, boolean tight, boolean started) {
+        if (i == digits.length)
+            return 1;
+
+        String key = i + "," + last + "," + tight + "," + started;
+        if (memo.containsKey(key))
+            return memo.get(key);
+
+        int up = tight ? digits[i] : base - 1;
+        int ways = 0;
+
+        for (int d = 0; d <= up; d++) {
+            boolean newTight = tight && (d == up);
+            if (!started) {
+                if (d == 0) {
+                    ways = (ways + dp(i + 1, -1, newTight, false)) % MOD;
+                } else {
+                    ways = (ways + dp(i + 1, d, newTight, true)) % MOD;
+                }
+            } else {
+                if (d < last)
+                    continue;
+                ways = (ways + dp(i + 1, d, newTight, true)) % MOD;
+            }
+        }
+
+        memo.put(key, ways);
+        return ways;
+    }
+}