Added tasks 2321, 2322.

javadev · web-flow · commit 5fcb6ff5246d · 2022-06-30T05:02:03.000+03:00
diff --git a/README.md b/README.md
@@ -1485,6 +1485,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.11'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2322 |[Minimum Score After Removals on a Tree](src/main/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/Solution.java)| Hard | Array, Bit_Manipulation, Tree, Depth_First_Search | 255 | 70.70
+| 2321 |[Maximum Score Of Spliced Array](src/main/java/g2301_2400/s2321_maximum_score_of_spliced_array/Solution.java)| Hard | Array, Dynamic_Programming | 3 | 99.68
 | 2320 |[Count Number of Ways to Place Houses](src/main/java/g2301_2400/s2320_count_number_of_ways_to_place_houses/Solution.java)| Medium | Dynamic_Programming | 13 | 82.46
 | 2319 |[Check if Matrix Is X-Matrix](src/main/java/g2301_2400/s2319_check_if_matrix_is_x_matrix/Solution.java)| Easy | Array, Matrix | 3 | 53.58
 | 2318 |[Number of Distinct Roll Sequences](src/main/java/g2301_2400/s2318_number_of_distinct_roll_sequences/Solution.java)| Hard | Dynamic_Programming, Memoization | 254 | 91.67
diff --git a/src/main/java/g2301_2400/s2321_maximum_score_of_spliced_array/Solution.java b/src/main/java/g2301_2400/s2321_maximum_score_of_spliced_array/Solution.java
@@ -0,0 +1,51 @@
+package g2301_2400.s2321_maximum_score_of_spliced_array;
+
+// #Hard #Array #Dynamic_Programming #2022_06_30_Time_3_ms_(99.68%)_Space_79.3_MB_(84.76%)
+
+public class Solution {
+    public int maximumsSplicedArray(int[] nums1, int[] nums2) {
+        int sum1 = 0;
+        int sum2 = 0;
+        int n = nums1.length;
+        for (int num : nums1) {
+            sum1 += num;
+        }
+        for (int num : nums2) {
+            sum2 += num;
+        }
+        if (sum2 > sum1) {
+            int temp = sum2;
+            sum2 = sum1;
+            sum1 = temp;
+            int[] temparr = nums2;
+            nums2 = nums1;
+            nums1 = temparr;
+        }
+        // now sum1>=sum2
+        // maxEndingHere denotes the maximum sum subarray ending at current index(ie. element at
+        // current index has to be included)
+        // minEndingHere denotes the minimum sum subarray ending at current index
+        int maxEndingHere;
+        int minEndingHere;
+        int maxSoFar;
+        int minSoFar;
+        int currEle;
+        maxEndingHere = minEndingHere = maxSoFar = minSoFar = nums2[0] - nums1[0];
+        for (int i = 1; i < n; i++) {
+            currEle = nums2[i] - nums1[i];
+            minEndingHere += currEle;
+            maxEndingHere += currEle;
+            if (maxEndingHere < currEle) {
+                maxEndingHere = currEle;
+            }
+            if (minEndingHere > currEle) {
+                minEndingHere = currEle;
+            }
+            maxSoFar = Math.max(maxEndingHere, maxSoFar);
+            minSoFar = Math.min(minEndingHere, minSoFar);
+        }
+        // return the maximum of the 2 possibilities dicussed
+        // also keep care that maxSoFar>=0 and maxSoFar<=0
+        return Math.max(sum1 + Math.max(maxSoFar, 0), sum2 - Math.min(0, minSoFar));
+    }
+}
diff --git a/src/main/java/g2301_2400/s2321_maximum_score_of_spliced_array/readme.md b/src/main/java/g2301_2400/s2321_maximum_score_of_spliced_array/readme.md
@@ -0,0 +1,53 @@
+2321\. Maximum Score Of Spliced Array
+
+Hard
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2`, both of length `n`.
+
+You can choose two integers `left` and `right` where `0 <= left <= right < n` and **swap** the subarray `nums1[left...right]` with the subarray `nums2[left...right]`.
+
+*   For example, if `nums1 = [1,2,3,4,5]` and `nums2 = [11,12,13,14,15]` and you choose `left = 1` and `right = 2`, `nums1` becomes `[1,**<ins>12,13</ins>**,4,5]` and `nums2` becomes `[11,**<ins>2,3</ins>**,14,15]`.
+
+You may choose to apply the mentioned operation **once** or not do anything.
+
+The **score** of the arrays is the **maximum** of `sum(nums1)` and `sum(nums2)`, where `sum(arr)` is the sum of all the elements in the array `arr`.
+
+Return _the **maximum possible score**_.
+
+A **subarray** is a contiguous sequence of elements within an array. `arr[left...right]` denotes the subarray that contains the elements of `nums` between indices `left` and `right` (**inclusive**).
+
+**Example 1:**
+
+**Input:** nums1 = [60,60,60], nums2 = [10,90,10]
+
+**Output:** 210
+
+**Explanation:** Choosing left = 1 and right = 1, we have nums1 = [60,<ins>**90**</ins>,60] and nums2 = [10,<ins>**60**</ins>,10].
+
+The score is max(sum(nums1), sum(nums2)) = max(210, 80) = 210.
+
+**Example 2:**
+
+**Input:** nums1 = [20,40,20,70,30], nums2 = [50,20,50,40,20]
+
+**Output:** 220
+
+**Explanation:** Choosing left = 3, right = 4, we have nums1 = [20,40,20,<ins>**40,20**</ins>] and nums2 = [50,20,50,<ins>**70,30**</ins>].
+
+The score is max(sum(nums1), sum(nums2)) = max(140, 220) = 220. 
+
+**Example 3:**
+
+**Input:** nums1 = [7,11,13], nums2 = [1,1,1]
+
+**Output:** 31
+
+**Explanation:** We choose not to swap any subarray.
+
+The score is max(sum(nums1), sum(nums2)) = max(31, 3) = 31. 
+
+**Constraints:**
+
+*   `n == nums1.length == nums2.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i], nums2[i] <= 10<sup>4</sup></code>
diff --git a/src/main/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/Solution.java b/src/main/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/Solution.java
@@ -0,0 +1,84 @@
+package g2301_2400.s2322_minimum_score_after_removals_on_a_tree;
+
+// #Hard #Array #Bit_Manipulation #Tree #Depth_First_Search
+// #2022_06_30_Time_255_ms_(70.70%)_Space_117.2_MB_(57.14%)
+
+import java.util.ArrayList;
+
+@SuppressWarnings("unchecked")
+public class Solution {
+    private int ans = Integer.MAX_VALUE;
+
+    // function to travel 2nd time on the tree and find the second edge to be removed
+    private int helper(
+            int src, ArrayList<Integer>[] graph, int[] arr, int par, int block, int xor1, int tot) {
+        // Setting the value for the current subtree's XOR value
+        int myXOR = arr[src];
+        for (int nbr : graph[src]) {
+            // If the current nbr is niether the parent of this node nor the blocked node  , then
+            // only we'll proceed
+            if (nbr != par && nbr != block) {
+                int nbrXOR = helper(nbr, graph, arr, src, block, xor1, tot);
+                // 'src <----> nbr' is the second edge to be removed
+                // Getting the XOR value of the current neighbor
+                int xor2 = nbrXOR;
+                // The XOR of the remaining component
+                int xor3 = (tot ^ xor1) ^ xor2;
+                // Getting the minimum of the three values
+                int max = Math.max(xor1, Math.max(xor2, xor3));
+                // Getting the maximum of the three value
+                int min = Math.min(xor1, Math.min(xor2, xor3));
+                ans = Math.min(ans, max - min);
+                // Including the neighbour subtree's XOR value in the XOR value of the subtree
+                // rooted at src node
+                myXOR ^= nbrXOR;
+            }
+        }
+        // Returing the XOR value of the current subtree rooted at the src node
+        return myXOR;
+    }
+
+    // function to travel 1st time on the tree and find the first edge to be removed and
+    // then block the node at which the edge ends to avoid selecting the same node again
+    private int dfs(int src, ArrayList<Integer>[] graph, int[] arr, int par, int tot) {
+        // Setting the value for the current subtree's XOR value
+        int myXOR = arr[src];
+        for (int nbr : graph[src]) {
+            // If the current nbr is not the parent of this node, then only we'll proceed
+            if (nbr != par) {
+                // After selecting 'src <----> nbr' as the first edge, we block 'nbr' node and then
+                // make a call to try all the second edges
+                int nbrXOR = dfs(nbr, graph, arr, src, tot);
+                // Calling the helper to find the try all the second edges after blocking the
+                // current node
+                helper(0, graph, arr, -1, nbr, nbrXOR, tot);
+                // Including the neighbour subtree's XOR value in the XOR value of the subtree
+                // rooted at src node
+                myXOR ^= nbrXOR;
+            }
+        }
+        // Returing the XOR value of the current subtree rooted at the src node
+        return myXOR;
+    }
+
+    public int minimumScore(int[] arr, int[][] edges) {
+        int n = arr.length;
+        ArrayList<Integer>[] graph = new ArrayList[n];
+        int tot = 0;
+        for (int i = 0; i < n; i++) {
+            // Initializing the graph and finding the total XOR
+            graph[i] = new ArrayList<>();
+            tot ^= arr[i];
+        }
+        for (int[] edge : edges) {
+            // adding the edges
+            int u = edge[0];
+            int v = edge[1];
+            graph[u].add(v);
+            graph[v].add(u);
+        }
+        ans = Integer.MAX_VALUE;
+        dfs(0, graph, arr, -1, tot);
+        return ans;
+    }
+}
diff --git a/src/main/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/readme.md b/src/main/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/readme.md
@@ -0,0 +1,67 @@
+2322\. Minimum Score After Removals on a Tree
+
+Hard
+
+There is an undirected connected tree with `n` nodes labeled from `0` to `n - 1` and `n - 1` edges.
+
+You are given a **0-indexed** integer array `nums` of length `n` where `nums[i]` represents the value of the <code>i<sup>th</sup></code> node. You are also given a 2D integer array `edges` of length `n - 1` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.
+
+Remove two **distinct** edges of the tree to form three connected components. For a pair of removed edges, the following steps are defined:
+
+1.  Get the XOR of all the values of the nodes for **each** of the three components respectively.
+2.  The **difference** between the **largest** XOR value and the **smallest** XOR value is the **score** of the pair.
+
+*   For example, say the three components have the node values: `[4,5,7]`, `[1,9]`, and `[3,3,3]`. The three XOR values are `4 ^ 5 ^ 7 = <ins>**6**</ins>`, `1 ^ 9 = <ins>**8**</ins>`, and `3 ^ 3 ^ 3 = <ins>**3**</ins>`. The largest XOR value is `8` and the smallest XOR value is `3`. The score is then `8 - 3 = 5`.
+
+Return _the **minimum** score of any possible pair of edge removals on the given tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/05/03/ex1drawio.png)
+
+**Input:** nums = [1,5,5,4,11], edges = [[0,1],[1,2],[1,3],[3,4]]
+
+**Output:** 9
+
+**Explanation:** The diagram above shows a way to make a pair of removals.
+
+- The 1<sup>st</sup> component has nodes [1,3,4] with values [5,4,11]. Its XOR value is 5 ^ 4 ^ 11 = 10.
+
+- The 2<sup>nd</sup> component has node [0] with value [1]. Its XOR value is 1 = 1.
+
+- The 3<sup>rd</sup> component has node [2] with value [5]. Its XOR value is 5 = 5.
+
+The score is the difference between the largest and smallest XOR value which is 10 - 1 = 9.
+
+It can be shown that no other pair of removals will obtain a smaller score than 9. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/05/03/ex2drawio.png)
+
+**Input:** nums = [5,5,2,4,4,2], edges = [[0,1],[1,2],[5,2],[4,3],[1,3]]
+
+**Output:** 0
+
+**Explanation:** The diagram above shows a way to make a pair of removals.
+
+- The 1<sup>st</sup> component has nodes [3,4] with values [4,4]. Its XOR value is 4 ^ 4 = 0.
+
+- The 2<sup>nd</sup> component has nodes [1,0] with values [5,5]. Its XOR value is 5 ^ 5 = 0.
+
+- The 3<sup>rd</sup> component has nodes [2,5] with values [2,2]. Its XOR value is 2 ^ 2 = 0.
+
+The score is the difference between the largest and smallest XOR value which is 0 - 0 = 0.
+
+We cannot obtain a smaller score than 0. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `3 <= n <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>8</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   `edges` represents a valid tree.
diff --git a/src/test/java/g1101_1200/s1195_fizz_buzz_multithreaded/FizzBuzzTest.java b/src/test/java/g1101_1200/s1195_fizz_buzz_multithreaded/FizzBuzzTest.java
@@ -47,7 +47,7 @@ void fizzBuzz() throws InterruptedException {
                             }
                         })
                 .start();
-        TimeUnit.MILLISECONDS.sleep(500);
+        TimeUnit.MILLISECONDS.sleep(600);
         assertThat(fizz[0] > 0, equalTo(true));
     }
 
@@ -90,7 +90,7 @@ void fizzBuzz2() throws InterruptedException {
                             }
                         })
                 .start();
-        TimeUnit.MILLISECONDS.sleep(500);
+        TimeUnit.MILLISECONDS.sleep(600);
         assertThat(fizz[0] >= 0, equalTo(true));
     }
 }
diff --git a/src/test/java/g2301_2400/s2321_maximum_score_of_spliced_array/SolutionTest.java b/src/test/java/g2301_2400/s2321_maximum_score_of_spliced_array/SolutionTest.java
@@ -0,0 +1,38 @@
+package g2301_2400.s2321_maximum_score_of_spliced_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximumsSplicedArray() {
+        assertThat(
+                new Solution().maximumsSplicedArray(new int[] {60, 60, 60}, new int[] {10, 90, 10}),
+                equalTo(210));
+    }
+
+    @Test
+    void maximumsSplicedArray2() {
+        assertThat(
+                new Solution()
+                        .maximumsSplicedArray(
+                                new int[] {20, 40, 20, 70, 30}, new int[] {50, 20, 50, 40, 20}),
+                equalTo(220));
+    }
+
+    @Test
+    void maximumsSplicedArray3() {
+        assertThat(
+                new Solution().maximumsSplicedArray(new int[] {7, 11, 13}, new int[] {1, 1, 1}),
+                equalTo(31));
+    }
+
+    @Test
+    void maximumsSplicedArray4() {
+        assertThat(
+                new Solution().maximumsSplicedArray(new int[] {1, 1, 1}, new int[] {7, 11, 13}),
+                equalTo(31));
+    }
+}
diff --git a/src/test/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/SolutionTest.java b/src/test/java/g2301_2400/s2322_minimum_score_after_removals_on_a_tree/SolutionTest.java
@@ -0,0 +1,28 @@
+package g2301_2400.s2322_minimum_score_after_removals_on_a_tree;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumScore() {
+        assertThat(
+                new Solution()
+                        .minimumScore(
+                                new int[] {1, 5, 5, 4, 11},
+                                new int[][] {{0, 1}, {1, 2}, {1, 3}, {3, 4}}),
+                equalTo(9));
+    }
+
+    @Test
+    void minimumScore2() {
+        assertThat(
+                new Solution()
+                        .minimumScore(
+                                new int[] {5, 5, 2, 4, 4, 2},
+                                new int[][] {{0, 1}, {1, 2}, {5, 2}, {4, 3}, {1, 3}}),
+                equalTo(0));
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ void fizzBuzz() throws InterruptedException {`
`47`	`47`	`}`
`48`	`48`	`})`
`49`	`49`	`.start();`
`50`		`- TimeUnit.MILLISECONDS.sleep(500);`
	`50`	`+ TimeUnit.MILLISECONDS.sleep(600);`
`51`	`51`	`assertThat(fizz[0] > 0, equalTo(true));`
`52`	`52`	`}`
`53`	`53`
`@@ -90,7 +90,7 @@ void fizzBuzz2() throws InterruptedException {`
`90`	`90`	`}`
`91`	`91`	`})`
`92`	`92`	`.start();`
`93`		`- TimeUnit.MILLISECONDS.sleep(500);`
	`93`	`+ TimeUnit.MILLISECONDS.sleep(600);`
`94`	`94`	`assertThat(fizz[0] >= 0, equalTo(true));`
`95`	`95`	`}`
`96`	`96`	`}`