Added tasks 2843-2848

Author: ThanhNIT

src/main/java/g2801_2900/s2843_count_symmetric_integers/Solution.java

@@ -0,0 +1,30 @@
+package g2801_2900.s2843_count_symmetric_integers;
+
+// #Easy #Math #Enumeration #2023_12_13_Time_26_ms_(80.87%)_Space_43.9_MB_(8.49%)
+
+public class Solution {
+    public int countSymmetricIntegers(int low, int high) {
+        int count = 0;
+        for (int i = low; i <= high; i++) {
+            if (isSymmetric(i)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private boolean isSymmetric(int num) {
+        String str = String.valueOf(num);
+        int n = str.length();
+        if (n % 2 != 0) {
+            return false;
+        }
+        int leftSum = 0;
+        int rightSum = 0;
+        for (int i = 0, j = n - 1; i < j; i++, j--) {
+            leftSum += str.charAt(i) - '0';
+            rightSum += str.charAt(j) - '0';
+        }
+        return leftSum == rightSum;
+    }
+}

src/main/java/g2801_2900/s2843_count_symmetric_integers/readme.md

@@ -0,0 +1,29 @@
+2843\. Count Symmetric Integers
+
+Easy
+
+You are given two positive integers `low` and `high`.
+
+An integer `x` consisting of `2 * n` digits is **symmetric** if the sum of the first `n` digits of `x` is equal to the sum of the last `n` digits of `x`. Numbers with an odd number of digits are never symmetric.
+
+Return _the **number of symmetric** integers in the range_ `[low, high]`.
+
+**Example 1:**
+
+**Input:** low = 1, high = 100
+
+**Output:** 9
+
+**Explanation:** There are 9 symmetric integers between 1 and 100: 11, 22, 33, 44, 55, 66, 77, 88, and 99.
+
+**Example 2:**
+
+**Input:** low = 1200, high = 1230
+
+**Output:** 4
+
+**Explanation:** There are 4 symmetric integers between 1200 and 1230: 1203, 1212, 1221, and 1230.
+
+**Constraints:**
+
+*   <code>1 <= low <= high <= 10<sup>4</sup></code>

src/main/java/g2801_2900/s2844_minimum_operations_to_make_a_special_number/Solution.java

@@ -0,0 +1,34 @@
+package g2801_2900.s2844_minimum_operations_to_make_a_special_number;
+
+// #Medium #String #Math #Greedy #Enumeration #2023_12_13_Time_1_ms_(100.00%)_Space_41_MB_(68.09%)
+
+public class Solution {
+    public int minimumOperations(String num) {
+        char[] number = num.toCharArray();
+        int n = number.length;
+        int zero = 0;
+        int five = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            if (number[i] == '0') {
+                if (zero == 1) {
+                    return n - i - 2;
+                } else {
+                    zero++;
+                }
+            } else if (number[i] == '5') {
+                if (zero == 1) {
+                    return n - i - 2;
+                }
+                if (five == 0) {
+                    five++;
+                }
+            } else if ((number[i] == '2' || number[i] == '7') && five == 1) {
+                return n - i - 2;
+            }
+        }
+        if (zero == 1) {
+            return n - 1;
+        }
+        return n;
+    }
+}

src/main/java/g2801_2900/s2844_minimum_operations_to_make_a_special_number/readme.md

@@ -0,0 +1,41 @@
+2844\. Minimum Operations to Make a Special Number
+
+Medium
+
+You are given a **0-indexed** string `num` representing a non-negative integer.
+
+In one operation, you can pick any digit of `num` and delete it. Note that if you delete all the digits of `num`, `num` becomes `0`.
+
+Return _the **minimum number of operations** required to make_ `num` _special_.
+
+An integer `x` is considered **special** if it is divisible by `25`.
+
+**Example 1:**
+
+**Input:** num = "2245047"
+
+**Output:** 2
+
+**Explanation:** Delete digits num[5] and num[6]. The resulting number is "22450" which is special since it is divisible by 25. It can be shown that 2 is the minimum number of operations required to get a special number.
+
+**Example 2:**
+
+**Input:** num = "2908305"
+
+**Output:** 3
+
+**Explanation:** Delete digits num[3], num[4], and num[6]. The resulting number is "2900" which is special since it is divisible by 25. It can be shown that 3 is the minimum number of operations required to get a special number.
+
+**Example 3:**
+
+**Input:** num = "10"
+
+**Output:** 1
+
+**Explanation:** Delete digit num[0]. The resulting number is "0" which is special since it is divisible by 25. It can be shown that 1 is the minimum number of operations required to get a special number.
+
+**Constraints:**
+
+*   `1 <= num.length <= 100`
+*   `num` only consists of digits `'0'` through `'9'`.
+*   `num` does not contain any leading zeros.

src/main/java/g2801_2900/s2845_count_of_interesting_subarrays/Solution.java

@@ -0,0 +1,25 @@
+package g2801_2900.s2845_count_of_interesting_subarrays;
+
+// #Medium #Array #Hash_Table #Prefix_Sum #2023_12_13_Time_27_ms_(97.76%)_Space_62.7_MB_(26.12%)
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public long countInterestingSubarrays(List<Integer> nums, int modulo, int k) {
+        int prefixCnt = 0;
+        Map<Integer, Integer> freq = new HashMap<>();
+        freq.put(0, 1);
+        long interestingSubarrays = 0;
+        for (Integer num : nums) {
+            if (num % modulo == k) {
+                prefixCnt++;
+            }
+            int expectedPrefix = (prefixCnt - k + modulo) % modulo;
+            interestingSubarrays += freq.getOrDefault(expectedPrefix, 0);
+            freq.put(prefixCnt % modulo, freq.getOrDefault(prefixCnt % modulo, 0) + 1);
+        }
+        return interestingSubarrays;
+    }
+}

src/main/java/g2801_2900/s2845_count_of_interesting_subarrays/readme.md

@@ -0,0 +1,52 @@
+2845\. Count of Interesting Subarrays
+
+Medium
+
+You are given a **0-indexed** integer array `nums`, an integer `modulo`, and an integer `k`.
+
+Your task is to find the count of subarrays that are **interesting**.
+
+A **subarray** `nums[l..r]` is **interesting** if the following condition holds:
+
+*   Let `cnt` be the number of indices `i` in the range `[l, r]` such that `nums[i] % modulo == k`. Then, `cnt % modulo == k`.
+
+Return _an integer denoting the count of interesting subarrays._
+
+**Note:** A subarray is _a contiguous non-empty sequence of elements within an array_.
+
+**Example 1:**
+
+**Input:** nums = [3,2,4], modulo = 2, k = 1
+
+**Output:** 3
+
+**Explanation:** In this example the interesting subarrays are: The subarray nums[0..0] which is [3]. 
+- There is only one index, i = 0, in the range [0, 0] that satisfies nums[i] % modulo == k. 
+- Hence, cnt = 1 and cnt % modulo == k. The subarray nums[0..1] which is [3,2]. 
+- There is only one index, i = 0, in the range [0, 1] that satisfies nums[i] % modulo == k. 
+- Hence, cnt = 1 and cnt % modulo == k. The subarray nums[0..2] which is [3,2,4]. 
+- There is only one index, i = 0, in the range [0, 2] that satisfies nums[i] % modulo == k. 
+- Hence, cnt = 1 and cnt % modulo == k.
+
+It can be shown that there are no other interesting subarrays. So, the answer is 3.
+
+**Example 2:**
+
+**Input:** nums = [3,1,9,6], modulo = 3, k = 0
+
+**Output:** 2
+
+**Explanation:** In this example the interesting subarrays are: The subarray nums[0..3] which is [3,1,9,6]. 
+- There are three indices, i = 0, 2, 3, in the range [0, 3] that satisfy nums[i] % modulo == k. 
+- Hence, cnt = 3 and cnt % modulo == k. The subarray nums[1..1] which is [1]. 
+- There is no index, i, in the range [1, 1] that satisfies nums[i] % modulo == k. 
+- Hence, cnt = 0 and cnt % modulo == k. 
+
+It can be shown that there are no other interesting subarrays. So, the answer is 2.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= modulo <= 10<sup>9</sup></code>
+*   `0 <= k < modulo`

src/main/java/g2801_2900/s2846_minimum_edge_weight_equilibrium_queries_in_a_tree/Solution.java

@@ -0,0 +1,152 @@
+package g2801_2900.s2846_minimum_edge_weight_equilibrium_queries_in_a_tree;
+
+// #Hard #Array #Tree #Graph #Strongly_Connected_Component
+// #2023_12_13_Time_74_ms_(66.04%)_Space_57_MB_(50.94%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@SuppressWarnings("java:S107")
+public class Solution {
+    private static class Node {
+        int v;
+        int w;
+
+        Node(int v, int w) {
+            this.v = v;
+            this.w = w;
+        }
+    }
+
+    public int[] minOperationsQueries(int n, int[][] edges, int[][] queries) {
+        List<List<Node>> graph = createGraph(edges, n);
+        int queryCount = queries.length;
+        int[] res = new int[queryCount];
+        int[] parent = new int[n];
+        int[] level = new int[n];
+        int[][] weightFreq = new int[n][27];
+        int[] freq = new int[27];
+        int height = (int) (Math.log(n) / Math.log(2)) + 1;
+        int[][] up = new int[n][height];
+        for (int[] arr : up) {
+            Arrays.fill(arr, -1);
+        }
+        dfs(graph, 0, 0, -1, parent, level, weightFreq, freq);
+        for (int i = 0; i < n; i++) {
+            up[i][0] = parent[i];
+        }
+        for (int i = 1; i < height; i++) {
+            for (int j = 0; j < n; j++) {
+                if (up[j][i - 1] == -1) {
+                    up[j][i] = -1;
+                    continue;
+                }
+                up[j][i] = up[up[j][i - 1]][i - 1];
+            }
+        }
+        for (int i = 0; i < queryCount; i++) {
+            int src = queries[i][0];
+            int dest = queries[i][1];
+            int lcaNode = lca(src, dest, up, height, level);
+            res[i] = processResult(weightFreq[src], weightFreq[dest], weightFreq[lcaNode]);
+        }
+        return res;
+    }
+
+    private int lca(int src, int dest, int[][] up, int height, int[] level) {
+        int curr1 = src;
+        int curr2 = dest;
+        int minlevel;
+        if (level[curr1] > level[curr2]) {
+            minlevel = level[curr2];
+            curr1 = getKthAncestor(curr1, level[curr1] - level[curr2], up, height);
+        } else if (level[curr1] <= level[curr2]) {
+            minlevel = level[curr1];
+            curr2 = getKthAncestor(curr2, level[curr2] - level[curr1], up, height);
+        } else {
+            minlevel = level[curr1];
+        }
+        if (curr1 == curr2) {
+            return curr1;
+        }
+        int l = 0;
+        int h = level[curr2];
+        while (l <= h) {
+            int mid = l + (h - l) / 2;
+            int p1 = getKthAncestor(curr1, minlevel - mid, up, height);
+            int p2 = getKthAncestor(curr2, minlevel - mid, up, height);
+            if (p1 == p2) {
+                l = mid + 1;
+            } else {
+                h = mid - 1;
+            }
+        }
+        return getKthAncestor(curr1, minlevel - l + 1, up, height);
+    }
+
+    private int getKthAncestor(int node, int k, int[][] up, int height) {
+        int curr = node;
+        for (int i = 0; i < height && k >> i != 0; i++) {
+            if (((1 << i) & k) != 0) {
+                if (curr == -1) {
+                    return -1;
+                }
+                curr = up[curr][i];
+            }
+        }
+        return curr;
+    }
+
+    private int processResult(int[] freqSrc, int[] freqDest, int[] freqLCA) {
+        int[] freqPath = new int[27];
+        for (int i = 1; i < 27; i++) {
+            freqPath[i] = freqSrc[i] + freqDest[i] - 2 * freqLCA[i];
+        }
+        int max = 0;
+        int pathlen = 0;
+        for (int i = 1; i < 27; i++) {
+            max = Math.max(max, freqPath[i]);
+            pathlen += freqPath[i];
+        }
+        return pathlen - max;
+    }
+
+    private void dfs(
+            List<List<Node>> graph,
+            int src,
+            int currlevel,
+            int p,
+            int[] parent,
+            int[] level,
+            int[][] weightFreq,
+            int[] freq) {
+        parent[src] = p;
+        level[src] = currlevel;
+        System.arraycopy(freq, 0, weightFreq[src], 0, freq.length);
+        for (Node node : graph.get(src)) {
+            int v = node.v;
+            int w = node.w;
+            if (v != p) {
+                freq[w]++;
+                dfs(graph, v, currlevel + 1, src, parent, level, weightFreq, freq);
+                freq[w]--;
+            }
+        }
+    }
+
+    private List<List<Node>> createGraph(int[][] edges, int n) {
+        List<List<Node>> graph = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            graph.add(new ArrayList<>());
+        }
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            int w = edge[2];
+            graph.get(u).add(new Node(v, w));
+            graph.get(v).add(new Node(u, w));
+        }
+        return graph;
+    }
+}