Added tasks 2034, 2035, 2037.

Author: ThanhNIT

src/main/java/g2001_2100/s2034_stock_price_fluctuation/StockPrice.java

@@ -0,0 +1,78 @@
+package g2001_2100.s2034_stock_price_fluctuation;
+
+// #Medium #Hash_Table #Design #Heap_Priority_Queue #Ordered_Set #Data_Stream
+// #2022_05_25_Time_163_ms_(65.51%)_Space_155.8_MB_(37.90%)
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+public class StockPrice {
+    private static class Record {
+        Integer time;
+        Integer price;
+
+        Record(Integer time, Integer price) {
+            this.time = time;
+            this.price = price;
+        }
+    }
+
+    Map<Integer, Integer> map;
+    PriorityQueue<Record> maxHeap;
+    PriorityQueue<Record> minHeap;
+    Integer latestTimestamp = 0;
+
+    public StockPrice() {
+        map = new HashMap<>();
+        maxHeap =
+                new PriorityQueue<>(
+                        (r1, r2) -> {
+                            if (r1.price.equals(r2.price)) {
+                                return 0;
+                            } else {
+                                return r1.price > r2.price ? -1 : 1;
+                            }
+                        });
+        minHeap =
+                new PriorityQueue<>(
+                        (r1, r2) -> {
+                            if (r1.price.equals(r2.price)) {
+                                return 0;
+                            } else {
+                                return r1.price < r2.price ? -1 : 1;
+                            }
+                        });
+    }
+
+    public void update(int timestamp, int price) {
+        latestTimestamp = Math.max(timestamp, latestTimestamp);
+        maxHeap.offer(new Record(timestamp, price));
+        minHeap.offer(new Record(timestamp, price));
+        map.put(timestamp, price);
+    }
+
+    public int current() {
+        return map.get(latestTimestamp);
+    }
+
+    public int maximum() {
+        while (true) {
+            Record r = maxHeap.peek();
+            if (map.get(r.time).equals(r.price)) {
+                return r.price;
+            }
+            maxHeap.poll();
+        }
+    }
+
+    public int minimum() {
+        while (true) {
+            Record r = minHeap.peek();
+            if (map.get(r.time).equals(r.price)) {
+                return r.price;
+            }
+            minHeap.poll();
+        }
+    }
+}

src/main/java/g2001_2100/s2034_stock_price_fluctuation/readme.md

@@ -0,0 +1,54 @@
+2034\. Stock Price Fluctuation
+
+Medium
+
+You are given a stream of **records** about a particular stock. Each record contains a **timestamp** and the corresponding **price** of the stock at that timestamp.
+
+Unfortunately due to the volatile nature of the stock market, the records do not come in order. Even worse, some records may be incorrect. Another record with the same timestamp may appear later in the stream **correcting** the price of the previous wrong record.
+
+Design an algorithm that:
+
+*   **Updates** the price of the stock at a particular timestamp, **correcting** the price from any previous records at the timestamp.
+*   Finds the **latest price** of the stock based on the current records. The **latest price** is the price at the latest timestamp recorded.
+*   Finds the **maximum price** the stock has been based on the current records.
+*   Finds the **minimum price** the stock has been based on the current records.
+
+Implement the `StockPrice` class:
+
+*   `StockPrice()` Initializes the object with no price records.
+*   `void update(int timestamp, int price)` Updates the `price` of the stock at the given `timestamp`.
+*   `int current()` Returns the **latest price** of the stock.
+*   `int maximum()` Returns the **maximum price** of the stock.
+*   `int minimum()` Returns the **minimum price** of the stock.
+
+**Example 1:**
+
+**Input** ["StockPrice", "update", "update", "current", "maximum", "update", "maximum", "update", "minimum"] [[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
+
+**Output:** [null, null, null, 5, 10, null, 5, null, 2]
+
+**Explanation:** 
+
+StockPrice stockPrice = new StockPrice(); 
+
+stockPrice.update(1, 10); // Timestamps are [1] with corresponding prices [10]. 
+
+stockPrice.update(2, 5); // Timestamps are [1,2] with corresponding prices [10,5]. 
+
+stockPrice.current(); // return 5, the latest timestamp is 2 with the price being 5. 
+
+stockPrice.maximum(); // return 10, the maximum price is 10 at timestamp 1. 
+
+stockPrice.update(1, 3); // The previous timestamp 1 had the wrong price, so it is updated to 3. // Timestamps are [1,2] with corresponding prices [3,5]. 
+
+stockPrice.maximum(); // return 5, the maximum price is 5 after the correction. 
+
+stockPrice.update(4, 2); // Timestamps are [1,2,4] with corresponding prices [3,5,2]. 
+
+stockPrice.minimum(); // return 2, the minimum price is 2 at timestamp 4.
+
+**Constraints:**
+
+*   <code>1 <= timestamp, price <= 10<sup>9</sup></code>
+*   At most <code>10<sup>5</sup></code> calls will be made **in total** to `update`, `current`, `maximum`, and `minimum`.
+*   `current`, `maximum`, and `minimum` will be called **only after** `update` has been called **at least once**.

src/main/java/g2001_2100/s2035_partition_array_into_two_arrays_to_minimize_sum_difference/Solution.java

@@ -0,0 +1,73 @@
+package g2001_2100.s2035_partition_array_into_two_arrays_to_minimize_sum_difference;
+
+// #Hard #Array #Dynamic_Programming #Binary_Search #Two_Pointers #Bit_Manipulation #Ordered_Set
+// #Bitmask #2022_05_25_Time_1336_ms_(39.36%)_Space_117.6_MB_(50.53%)
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Solution {
+    public int minimumDifference(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return -1;
+        }
+        int n = nums.length / 2;
+        int sum = 0;
+        List<List<Integer>> arr1 = new ArrayList<>();
+        List<List<Integer>> arr2 = new ArrayList<>();
+        for (int i = 0; i <= n; i++) {
+            arr1.add(new ArrayList<>());
+            arr2.add(new ArrayList<>());
+            if (i < n) {
+                sum += nums[i];
+                sum += nums[i + n];
+            }
+        }
+        for (int state = 0; state < (1 << n); state++) {
+            int sum1 = 0;
+            int sum2 = 0;
+            for (int i = 0; i < n; i++) {
+                if ((state & (1 << i)) == 0) {
+                    continue;
+                }
+                int a1 = nums[i];
+                int a2 = nums[i + n];
+                sum1 += a1;
+                sum2 += a2;
+            }
+            int numOfEleInSet = Integer.bitCount(state);
+            arr1.get(numOfEleInSet).add(sum1);
+            arr2.get(numOfEleInSet).add(sum2);
+        }
+        for (int i = 0; i <= n; i++) {
+            Collections.sort(arr2.get(i));
+        }
+        int min = Integer.MAX_VALUE;
+        for (int i = 0; i <= n; i++) {
+            List<Integer> sums1 = arr1.get(i);
+            List<Integer> sums2 = arr2.get(n - i);
+            for (int s1 : sums1) {
+                int idx = Collections.binarySearch(sums2, sum / 2 - s1);
+                if (idx < 0) {
+                    idx = -(idx + 1);
+                }
+                if (idx < sums1.size()) {
+                    min =
+                            Math.min(
+                                    min,
+                                    Math.abs((sum - s1 - sums2.get(idx)) - (sums2.get(idx) + s1)));
+                }
+                if (idx - 1 >= 0) {
+                    min =
+                            Math.min(
+                                    min,
+                                    Math.abs(
+                                            (sum - s1 - sums2.get(idx - 1))
+                                                    - (sums2.get(idx - 1) + s1)));
+                }
+            }
+        }
+        return min;
+    }
+}

src/main/java/g2001_2100/s2035_partition_array_into_two_arrays_to_minimize_sum_difference/readme.md

@@ -0,0 +1,41 @@
+2035\. Partition Array Into Two Arrays to Minimize Sum Difference
+
+Hard
+
+You are given an integer array `nums` of `2 * n` integers. You need to partition `nums` into **two** arrays of length `n` to **minimize the absolute difference** of the **sums** of the arrays. To partition `nums`, put each element of `nums` into **one** of the two arrays.
+
+Return _the **minimum** possible absolute difference_.
+
+**Example 1:**
+
+![example-1](https://assets.leetcode.com/uploads/2021/10/02/ex1.png)
+
+**Input:** nums = [3,9,7,3]
+
+**Output:** 2
+
+**Explanation:** One optimal partition is: [3,9] and [7,3]. The absolute difference between the sums of the arrays is abs((3 + 9) - (7 + 3)) = 2.
+
+**Example 2:**
+
+**Input:** nums = [-36,36]
+
+**Output:** 72
+
+**Explanation:** One optimal partition is: [-36] and [36]. The absolute difference between the sums of the arrays is abs((-36) - (36)) = 72.
+
+**Example 3:**
+
+![example-3](https://assets.leetcode.com/uploads/2021/10/02/ex3.png)
+
+**Input:** nums = [2,-1,0,4,-2,-9]
+
+**Output:** 0
+
+**Explanation:** One optimal partition is: [2,4,-9] and [-1,0,-2]. The absolute difference between the sums of the arrays is abs((2 + 4 + -9) - (-1 + 0 + -2)) = 0.
+
+**Constraints:**
+
+*   `1 <= n <= 15`
+*   `nums.length == 2 * n`
+*   <code>-10<sup>7</sup> <= nums[i] <= 10<sup>7</sup></code>

src/main/java/g2001_2100/s2037_minimum_number_of_moves_to_seat_everyone/Solution.java

@@ -0,0 +1,17 @@
+package g2001_2100.s2037_minimum_number_of_moves_to_seat_everyone;
+
+// #Easy #Array #Sorting #2022_05_25_Time_5_ms_(22.01%)_Space_43.7_MB_(67.19%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minMovesToSeat(int[] seats, int[] students) {
+        int ans = 0;
+        Arrays.sort(seats);
+        Arrays.sort(students);
+        for (int i = 0; i < seats.length; i++) {
+            ans += Math.abs(seats[i] - students[i]);
+        }
+        return ans;
+    }
+}

src/main/java/g2001_2100/s2037_minimum_number_of_moves_to_seat_everyone/readme.md

@@ -0,0 +1,77 @@
+2037\. Minimum Number of Moves to Seat Everyone
+
+Easy
+
+There are `n` seats and `n` students in a room. You are given an array `seats` of length `n`, where `seats[i]` is the position of the <code>i<sup>th</sup></code> seat. You are also given the array `students` of length `n`, where `students[j]` is the position of the <code>j<sup>th</sup></code> student.
+
+You may perform the following move any number of times:
+
+*   Increase or decrease the position of the <code>i<sup>th</sup></code> student by `1` (i.e., moving the <code>i<sup>th</sup></code> student from position `x` to `x + 1` or `x - 1`)
+
+Return _the **minimum number of moves** required to move each student to a seat_ _such that no two students are in the same seat._
+
+Note that there may be **multiple** seats or students in the **same** position at the beginning.
+
+**Example 1:**
+
+**Input:** seats = [3,1,5], students = [2,7,4]
+
+**Output:** 4
+
+**Explanation:** 
+
+The students are moved as follows: 
+
+- The first student is moved from from position 2 to position 1 using 1 move. 
+
+- The second student is moved from from position 7 to position 5 using 2 moves. 
+
+- The third student is moved from from position 4 to position 3 using 1 move. 
+  
+In total, 1 + 2 + 1 = 4 moves were used.
+
+**Example 2:**
+
+**Input:** seats = [4,1,5,9], students = [1,3,2,6]
+
+**Output:** 7
+
+**Explanation:** 
+
+The students are moved as follows: 
+
+- The first student is not moved. 
+
+- The second student is moved from from position 3 to position 4 using 1 move. 
+
+- The third student is moved from from position 2 to position 5 using 3 moves. 
+
+- The fourth student is moved from from position 6 to position 9 using 3 moves. 
+  
+In total, 0 + 1 + 3 + 3 = 7 moves were used.
+
+**Example 3:**
+
+**Input:** seats = [2,2,6,6], students = [1,3,2,6]
+
+**Output:** 4
+
+**Explanation:** Note that there are two seats at position 2 and two seats at position 6. 
+
+The students are moved as follows: 
+
+- The first student is moved from from position 1 to position 2 using 1 move. 
+
+- The second student is moved from from position 3 to position 6 using 3 moves. 
+
+- The third student is not moved. 
+
+- The fourth student is not moved. 
+  
+In total, 1 + 3 + 0 + 0 = 4 moves were used.
+
+**Constraints:**
+
+*   `n == seats.length == students.length`
+*   `1 <= n <= 100`
+*   `1 <= seats[i], students[j] <= 100`

src/test/java/g2001_2100/s2034_stock_price_fluctuation/StockPriceTest.java

@@ -0,0 +1,21 @@
+package g2001_2100.s2034_stock_price_fluctuation;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class StockPriceTest {
+    @Test
+    void stockPriceTest() {
+        StockPrice stockPrice = new StockPrice();
+        stockPrice.update(1, 10);
+        stockPrice.update(2, 5);
+        assertThat(stockPrice.current(), equalTo(5));
+        assertThat(stockPrice.maximum(), equalTo(10));
+        stockPrice.update(1, 3);
+        assertThat(stockPrice.maximum(), equalTo(5));
+        stockPrice.update(4, 2);
+        assertThat(stockPrice.minimum(), equalTo(2));
+    }
+}

src/test/java/g2001_2100/s2035_partition_array_into_two_arrays_to_minimize_sum_difference/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2035_partition_array_into_two_arrays_to_minimize_sum_difference;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumDifference() {
+        assertThat(new Solution().minimumDifference(new int[] {3, 9, 7, 3}), equalTo(2));
+    }
+
+    @Test
+    void minimumDifference2() {
+        assertThat(new Solution().minimumDifference(new int[] {-36, 36}), equalTo(72));
+    }
+
+    @Test
+    void minimumDifference3() {
+        assertThat(new Solution().minimumDifference(new int[] {2, -1, 0, 4, -2, -9}), equalTo(0));
+    }
+}