Added tasks 1937, 1938, 1941, 1942, 1943.

Author: ThanhNIT

src/main/java/g1901_2000/s1937_maximum_number_of_points_with_cost/Solution.java

@@ -0,0 +1,34 @@
+package g1901_2000.s1937_maximum_number_of_points_with_cost;
+
+// #Medium #Array #Dynamic_Programming #2022_05_16_Time_18_ms_(44.04%)_Space_128_MB_(22.97%)
+
+public class Solution {
+ public long maxPoints(int[][] points) {
+ int m = points[0].length;
+
+ long[] pre = new long[m];
+
+ for (int[] point : points) {
+ long[] current = new long[m];
+
+ long max = Long.MIN_VALUE;
+ for (int j = 0; j < m; j++) {
+ max = Math.max(max, pre[j] + j);
+ current[j] = Math.max(current[j], point[j] - j + max);
+ }
+
+ max = Long.MIN_VALUE;
+ for (int j = m - 1; j >= 0; j--) {
+ max = Math.max(max, pre[j] - j);
+ current[j] = Math.max(current[j], point[j] + j + max);
+ }
+ pre = current;
+ }
+
+ long max = Long.MIN_VALUE;
+ for (long val : pre) {
+ max = Math.max(max, val);
+ }
+ return max;
+ }
+}

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

@@ -0,0 +1,60 @@
+1937\. Maximum Number of Points with Cost
+
+Medium
+
+You are given an `m x n` integer matrix `points` (**0-indexed**). Starting with `0` points, you want to **maximize** the number of points you can get from the matrix.
+
+To gain points, you must pick one cell in **each row**. Picking the cell at coordinates `(r, c)` will **add** `points[r][c]` to your score.
+
+However, you will lose points if you pick a cell too far from the cell that you picked in the previous row. For every two adjacent rows `r` and `r + 1` (where `0 <= r < m - 1`), picking cells at coordinates <code>(r, c<sub>1</sub>)</code> and <code>(r + 1, c<sub>2</sub>)</code> will **subtract** <code>abs(c<sub>1</sub> - c<sub>2</sub>)</code> from your score.
+
+Return _the **maximum** number of points you can achieve_.
+
+`abs(x)` is defined as:
+
+* `x` for `x >= 0`.
+* `-x` for `x < 0`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/07/12/screenshot-2021-07-12-at-13-40-26-diagram-drawio-diagrams-net.png)
+
+**Input:** points = [[1,2,3],[1,5,1],[3,1,1]]
+
+**Output:** 9
+
+**Explanation:** 
+
+The blue cells denote the optimal cells to pick, which have coordinates (0, 2), (1, 1), and (2, 0). 
+
+You add 3 + 5 + 3 = 11 to your score. 
+
+However, you must subtract abs(2 - 1) + abs(1 - 0) = 2 from your score. 
+
+Your final score is 11 - 2 = 9.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/07/12/screenshot-2021-07-12-at-13-42-14-diagram-drawio-diagrams-net.png)
+
+**Input:** points = [[1,5],[2,3],[4,2]]
+
+**Output:** 11
+
+**Explanation:** 
+
+The blue cells denote the optimal cells to pick, which have coordinates (0, 1), (1, 1), and (2, 0).
+
+You add 5 + 3 + 4 = 12 to your score. 
+
+However, you must subtract abs(1 - 1) + abs(1 - 0) = 1 from your score. 
+
+Your final score is 12 - 1 = 11.
+
+**Constraints:**
+
+* `m == points.length`
+* `n == points[r].length`
+* <code>1 <= m, n <= 10<sup>5</sup></code>
+* <code>1 <= m * n <= 10<sup>5</sup></code>
+* <code>0 <= points[r][c] <= 10<sup>5</sup></code>

src/main/java/g1901_2000/s1938_maximum_genetic_difference_query/Solution.java

@@ -0,0 +1,50 @@
+package g1901_2000.s1938_maximum_genetic_difference_query;
+
+// #Hard #Array #Bit_Manipulation #Trie #2022_05_16_Time_174_ms_(100.00%)_Space_134.4_MB_(85.00%)
+
+public class Solution {
+ public int[] maxGeneticDifference(int[] parents, int[][] queries) {
+ int n = parents.length;
+ int[][] fd = new int[n][];
+ for (int i = 0; i < n; i++) {
+ fill(parents, n, fd, i);
+ }
+ int[] ret = new int[queries.length];
+ for (int q = 0; q < queries.length; q++) {
+ int cur = queries[q][0];
+ int value = queries[q][1];
+ for (int p = 30; p >= 0; p--) {
+ int msk = 1 << p;
+ if ((value & msk) != (cur & msk)) {
+ ret[q] |= msk;
+ } else if (fd[cur][p] >= 0) {
+ ret[q] |= msk;
+ cur = fd[cur][p];
+ }
+ }
+ }
+ return ret;
+ }
+
+ private void fill(int[] parents, int n, int[][] fd, int i) {
+ if (fd[i] == null) {
+ fd[i] = new int[31];
+ int a = parents[i];
+ if (a >= 0) {
+ fill(parents, n, fd, a);
+ }
+ for (int p = 30; p >= 0; p--) {
+ if (a == -1) {
+ fd[i][p] = -1;
+ } else {
+ if ((i & (1 << p)) == (a & (1 << p))) {
+ fd[i][p] = fd[a][p];
+ } else {
+ fd[i][p] = a;
+ a = fd[a][p];
+ }
+ }
+ }
+ }
+ }
+}

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

@@ -0,0 +1,50 @@
+1938\. Maximum Genetic Difference Query
+
+Hard
+
+There is a rooted tree consisting of `n` nodes numbered `0` to `n - 1`. Each node's number denotes its **unique genetic value** (i.e. the genetic value of node `x` is `x`). The **genetic difference** between two genetic values is defined as the **bitwise-****XOR** of their values. You are given the integer array `parents`, where `parents[i]` is the parent for node `i`. If node `x` is the **root** of the tree, then `parents[x] == -1`.
+
+You are also given the array `queries` where <code>queries[i] = [node<sub>i</sub>, val<sub>i</sub>]</code>. For each query `i`, find the **maximum genetic difference** between <code>val<sub>i</sub></code> and <code>p<sub>i</sub></code>, where <code>p<sub>i</sub></code> is the genetic value of any node that is on the path between <code>node<sub>i</sub></code> and the root (including <code>node<sub>i</sub></code> and the root). More formally, you want to maximize <code>val<sub>i</sub> XOR p<sub>i</sub></code>.
+
+Return _an array_ `ans` _where_ `ans[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/29/c1.png)
+
+**Input:** parents = [-1,0,1,1], queries = [[0,2],[3,2],[2,5]]
+
+**Output:** [2,3,7]
+
+**Explanation:** The queries are processed as follows: 
+
+- [0,2]: The node with the maximum genetic difference is 0, with a difference of 2 XOR 0 = 2. 
+
+- [3,2]: The node with the maximum genetic difference is 1, with a difference of 2 XOR 1 = 3. 
+
+- [2,5]: The node with the maximum genetic difference is 2, with a difference of 5 XOR 2 = 7.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/06/29/c2.png)
+
+**Input:** parents = [3,7,-1,2,0,7,0,2], queries = [[4,6],[1,15],[0,5]]
+
+**Output:** [6,14,7]
+
+**Explanation:** The queries are processed as follows: 
+
+- [4,6]: The node with the maximum genetic difference is 0, with a difference of 6 XOR 0 = 6. 
+
+- [1,15]: The node with the maximum genetic difference is 1, with a difference of 15 XOR 1 = 14. 
+
+- [0,5]: The node with the maximum genetic difference is 2, with a difference of 5 XOR 2 = 7.
+
+**Constraints:**
+
+* <code>2 <= parents.length <= 10<sup>5</sup></code>
+* `0 <= parents[i] <= parents.length - 1` for every node `i` that is **not** the root.
+* `parents[root] == -1`
+* <code>1 <= queries.length <= 3 * 10<sup>4</sup></code>
+* <code>0 <= node<sub>i</sub> <= parents.length - 1</code>
+* <code>0 <= val<sub>i</sub> <= 2 * 10<sup>5</sup></code>

src/main/java/g1901_2000/s1941_check_if_all_characters_have_equal_number_of_occurrences/Solution.java

@@ -0,0 +1,18 @@
+package g1901_2000.s1941_check_if_all_characters_have_equal_number_of_occurrences;
+
+// #Easy #String #Hash_Table #Counting #2022_05_16_Time_11_ms_(23.73%)_Space_42.6_MB_(36.57%)
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class Solution {
+ public boolean areOccurrencesEqual(String s) {
+ int[] counts = new int[26];
+ char[] charArray = s.toCharArray();
+ for (char c : charArray) {
+ counts[c - 'a']++;
+ }
+ return Arrays.stream(counts).filter(i -> i != 0).boxed().collect(Collectors.toSet()).size()
+ == 1;
+ }
+}

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

@@ -0,0 +1,28 @@
+1941\. Check if All Characters Have Equal Number of Occurrences
+
+Easy
+
+Given a string `s`, return `true` _if_ `s` _is a **good** string, or_ `false` _otherwise_.
+
+A string `s` is **good** if **all** the characters that appear in `s` have the **same** number of occurrences (i.e., the same frequency).
+
+**Example 1:**
+
+**Input:** s = "abacbc"
+
+**Output:** true
+
+**Explanation:** The characters that appear in s are 'a', 'b', and 'c'. All characters occur 2 times in s.
+
+**Example 2:**
+
+**Input:** s = "aaabb"
+
+**Output:** false
+
+**Explanation:** The characters that appear in s are 'a' and 'b'. 'a' occurs 3 times while 'b' occurs 2 times, which is not the same number of times.
+
+**Constraints:**
+
+* `1 <= s.length <= 1000`
+* `s` consists of lowercase English letters.

src/main/java/g1901_2000/s1942_the_number_of_the_smallest_unoccupied_chair/Solution.java

@@ -0,0 +1,55 @@
+package g1901_2000.s1942_the_number_of_the_smallest_unoccupied_chair;
+
+// #Medium #Array #Heap_Priority_Queue #Ordered_Set
+// #2022_05_16_Time_73_ms_(49.69%)_Space_73.1_MB_(38.04%)
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Solution {
+ public int smallestChair(int[][] times, int targetFriend) {
+ PriorityQueue<Integer> minheap = new PriorityQueue<>();
+ minheap.offer(0);
+ Person[] all = new Person[times.length * 2];
+ for (int i = 0; i < times.length; i++) {
+ all[2 * i] = new Person(i, times[i][0], false, true);
+ all[2 * i + 1] = new Person(i, times[i][1], true, false);
+ }
+ Arrays.sort(
+ all,
+ (a, b) -> {
+ int i = a.leave ? -1 : 1;
+ int j = b.leave ? -1 : 1;
+ return a.time == b.time ? i - j : a.time - b.time;
+ });
+
+ int[] seat = new int[times.length];
+ for (int i = 0; true; i++) {
+ if (all[i].arrive) {
+ if (targetFriend == all[i].idx) {
+ return minheap.peek();
+ }
+ seat[all[i].idx] = minheap.poll();
+ if (minheap.isEmpty()) {
+ minheap.offer(seat[all[i].idx] + 1);
+ }
+ } else {
+ minheap.offer(seat[all[i].idx]);
+ }
+ }
+ }
+
+ private static class Person {
+ boolean leave;
+ boolean arrive;
+ int time;
+ int idx;
+
+ Person(int idx, int time, boolean leave, boolean arrive) {
+ this.time = time;
+ this.leave = leave;
+ this.arrive = arrive;
+ this.idx = idx;
+ }
+ }
+}

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

@@ -0,0 +1,64 @@
+1942\. The Number of the Smallest Unoccupied Chair
+
+Medium
+
+There is a party where `n` friends numbered from `0` to `n - 1` are attending. There is an **infinite** number of chairs in this party that are numbered from `0` to `infinity`. When a friend arrives at the party, they sit on the unoccupied chair with the **smallest number**.
+
+* For example, if chairs `0`, `1`, and `5` are occupied when a friend comes, they will sit on chair number `2`.
+
+When a friend leaves the party, their chair becomes unoccupied at the moment they leave. If another friend arrives at that same moment, they can sit in that chair.
+
+You are given a **0-indexed** 2D integer array `times` where <code>times[i] = [arrival<sub>i</sub>, leaving<sub>i</sub>]</code>, indicating the arrival and leaving times of the <code>i<sup>th</sup></code> friend respectively, and an integer `targetFriend`. All arrival times are **distinct**.
+
+Return _the **chair number** that the friend numbered_ `targetFriend` _will sit on_.
+
+**Example 1:**
+
+**Input:** times = [[1,4],[2,3],[4,6]], targetFriend = 1
+
+**Output:** 1
+
+**Explanation:** 
+
+- Friend 0 arrives at time 1 and sits on chair 0. 
+
+- Friend 1 arrives at time 2 and sits on chair 1. 
+
+- Friend 1 leaves at time 3 and chair 1 becomes empty. 
+
+- Friend 0 leaves at time 4 and chair 0 becomes empty. 
+
+- Friend 2 arrives at time 4 and sits on chair 0. 
+ 
+Since friend 1 sat on chair 1, we return 1.
+
+**Example 2:**
+
+**Input:** times = [[3,10],[1,5],[2,6]], targetFriend = 0
+
+**Output:** 2
+
+**Explanation:** 
+
+- Friend 1 arrives at time 1 and sits on chair 0. 
+
+- Friend 2 arrives at time 2 and sits on chair 1. 
+
+- Friend 0 arrives at time 3 and sits on chair 2. 
+
+- Friend 1 leaves at time 5 and chair 0 becomes empty. 
+
+- Friend 2 leaves at time 6 and chair 1 becomes empty. 
+
+- Friend 0 leaves at time 10 and chair 2 becomes empty. 
+ 
+Since friend 0 sat on chair 2, we return 2.
+
+**Constraints:**
+
+* `n == times.length`
+* <code>2 <= n <= 10<sup>4</sup></code>
+* `times[i].length == 2`
+* <code>1 <= arrival<sub>i</sub> < leaving<sub>i</sub> <= 10<sup>5</sup></code>
+* `0 <= targetFriend <= n - 1`
+* Each <code>arrival<sub>i</sub></code> time is **distinct**.