Added tasks 2857-2861

Author: ThanhNIT

src/main/java/g2801_2900/s2857_count_pairs_of_points_with_distance_k/Solution.java

@@ -0,0 +1,35 @@
+package g2801_2900.s2857_count_pairs_of_points_with_distance_k;
+
+// #Medium #Array #Hash_Table #Bit_Manipulation
+// #2023_12_19_Time_250_ms_(84.21%)_Space_68.6_MB_(89.47%)
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+ public int countPairs(List<List<Integer>> c, int k) {
+ int ans = 0;
+ Map<Long, Integer> map = new HashMap<>();
+ for (List<Integer> p : c) {
+ int p0 = p.get(0);
+ int p1 = p.get(1);
+ for (int i = 0; i <= k; i++) {
+ int x1 = i ^ p0;
+ int y1 = (k - i) ^ p1;
+ long key2 = hash(x1, y1);
+ if (map.containsKey(key2)) {
+ ans += map.get(key2);
+ }
+ }
+ long key = hash(p0, p1);
+ map.put(key, map.getOrDefault(key, 0) + 1);
+ }
+ return ans;
+ }
+
+ private long hash(int x1, int y1) {
+ long r = (long) 1e8;
+ return x1 * r + y1;
+ }
+}

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

@@ -0,0 +1,33 @@
+2857\. Count Pairs of Points With Distance k
+
+Medium
+
+You are given a **2D** integer array `coordinates` and an integer `k`, where <code>coordinates[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> are the coordinates of the <code>i<sup>th</sup></code> point in a 2D plane.
+
+We define the **distance** between two points <code>(x<sub>1</sub>, y<sub>1</sub>)</code> and <code>(x<sub>2</sub>, y<sub>2</sub>)</code> as `(x1 XOR x2) + (y1 XOR y2)` where `XOR` is the bitwise `XOR` operation.
+
+Return _the number of pairs_ `(i, j)` _such that_ `i < j` _and the distance between points_ `i` _and_ `j` _is equal to_ `k`.
+
+**Example 1:**
+
+**Input:** coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
+
+**Output:** 2
+
+**Explanation:** We can choose the following pairs: 
+- (0,1): Because we have (1 XOR 4) + (2 XOR 2) = 5. 
+- (2,3): Because we have (1 XOR 5) + (3 XOR 2) = 5.
+
+**Example 2:**
+
+**Input:** coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
+
+**Output:** 10
+
+**Explanation:** Any two chosen pairs will have a distance of 0. There are 10 ways to choose two pairs.
+
+**Constraints:**
+
+* `2 <= coordinates.length <= 50000`
+* <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>6</sup></code>
+* `0 <= k <= 100`

src/main/java/g2801_2900/s2858_minimum_edge_reversals_so_every_node_is_reachable/Solution.java

@@ -0,0 +1,61 @@
+package g2801_2900.s2858_minimum_edge_reversals_so_every_node_is_reachable;
+
+// #Hard #Dynamic_Programming #Graph #Depth_First_Search #Breadth_First_Search
+// #2023_12_19_Time_52_ms_(92.31%)_Space_119.5_MB_(75.38%)
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Solution {
+ public int[] minEdgeReversals(int n, int[][] edges) {
+ List<int[]>[] nexts = new List[n];
+ for (int i = 0; i < n; i++) {
+ nexts[i] = new ArrayList<>();
+ }
+ for (int[] edge : edges) {
+ int u = edge[0];
+ int v = edge[1];
+ nexts[u].add(new int[] {1, v});
+ nexts[v].add(new int[] {-1, u});
+ }
+ int[] res = new int[n];
+ for (int i = 0; i < n; i++) {
+ res[i] = -1;
+ }
+ res[0] = dfs(nexts, 0, -1);
+ Queue<Integer> queue = new LinkedList<>();
+ queue.add(0);
+ while (!queue.isEmpty()) {
+ Integer index = queue.remove();
+ int val = res[index];
+ List<int[]> next = nexts[index];
+ for (int[] node : next) {
+ if (res[node[1]] == -1) {
+ if (node[0] == 1) {
+ res[node[1]] = val + 1;
+ } else {
+ res[node[1]] = val - 1;
+ }
+ queue.add(node[1]);
+ }
+ }
+ }
+ return res;
+ }
+
+ private int dfs(List<int[]>[] nexts, int index, int pre) {
+ int res = 0;
+ List<int[]> next = nexts[index];
+ for (int[] node : next) {
+ if (node[1] != pre) {
+ if (node[0] == -1) {
+ res++;
+ }
+ res += dfs(nexts, node[1], index);
+ }
+ }
+ return res;
+ }
+}

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

@@ -0,0 +1,71 @@
+2858\. Minimum Edge Reversals So Every Node Is Reachable
+
+Hard
+
+There is a **simple directed graph** with `n` nodes labeled from `0` to `n - 1`. The graph would form a **tree** if its edges were bi-directional.
+
+You are given an integer `n` and a **2D** integer array `edges`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> represents a **directed edge** going from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code>.
+
+An **edge reversal** changes the direction of an edge, i.e., a directed edge going from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code> becomes a directed edge going from node <code>v<sub>i</sub></code> to node <code>u<sub>i</sub></code>.
+
+For every node `i` in the range `[0, n - 1]`, your task is to **independently** calculate the **minimum** number of **edge reversals** required so it is possible to reach any other node starting from node `i` through a **sequence** of **directed edges**.
+
+Return _an integer array_ `answer`_, where_ `answer[i]` _is the_ _**minimum** number of **edge reversals** required so it is possible to reach any other node starting from node_ `i` _through a **sequence** of **directed edges**._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/08/26/image-20230826221104-3.png)
+
+**Input:** n = 4, edges = [[2,0],[2,1],[1,3]]
+
+**Output:** [1,1,0,2]
+
+**Explanation:** The image above shows the graph formed by the edges. 
+
+For node 0: after reversing the edge [2,0], it is possible to reach any other node starting from node 0. 
+
+So, answer[0] = 1. 
+
+For node 1: after reversing the edge [2,1], it is possible to reach any other node starting from node 1. 
+
+So, answer[1] = 1. 
+
+For node 2: it is already possible to reach any other node starting from node 2. 
+
+So, answer[2] = 0. 
+
+For node 3: after reversing the edges [1,3] and [2,1], it is possible to reach any other node starting from node 3. 
+
+So, answer[3] = 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/08/26/image-20230826225541-2.png)
+
+**Input:** n = 3, edges = [[1,2],[2,0]]
+
+**Output:** [2,0,1]
+
+**Explanation:** The image above shows the graph formed by the edges. 
+
+For node 0: after reversing the edges [2,0] and [1,2], it is possible to reach any other node starting from node 0. 
+
+So, answer[0] = 2. 
+
+For node 1: it is already possible to reach any other node starting from node 1. 
+
+So, answer[1] = 0. 
+
+For node 2: after reversing the edge [1, 2], it is possible to reach any other node starting from node 2. 
+
+So, answer[2] = 1.
+
+**Constraints:**
+
+* <code>2 <= n <= 10<sup>5</sup></code>
+* `edges.length == n - 1`
+* `edges[i].length == 2`
+* <code>0 <= u<sub>i</sub> == edges[i][0] < n</code>
+* <code>0 <= v<sub>i</sub> == edges[i][1] < n</code>
+* <code>u<sub>i</sub> != v<sub>i</sub></code>
+* The input is generated such that if the edges were bi-directional, the graph would be a tree.

src/main/java/g2801_2900/s2859_sum_of_values_at_indices_with_k_set_bits/Solution.java

@@ -0,0 +1,26 @@
+package g2801_2900.s2859_sum_of_values_at_indices_with_k_set_bits;
+
+// #Easy #Array #Bit_Manipulation #2023_12_19_Time_1_ms_(100.00%)_Space_43.3_MB_(64.43%)
+
+import java.util.List;
+
+public class Solution {
+ public int sumIndicesWithKSetBits(List<Integer> nums, int k) {
+ int sum = 0;
+ for (int i = 0; i < nums.size(); i++) {
+ if (countSetBits(i) == k) {
+ sum += nums.get(i);
+ }
+ }
+ return sum;
+ }
+
+ public static int countSetBits(int num) {
+ int count = 0;
+ while (num > 0) {
+ num = num & (num - 1);
+ count++;
+ }
+ return count;
+ }
+}

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

@@ -0,0 +1,55 @@
+2859\. Sum of Values at Indices With K Set Bits
+
+Easy
+
+You are given a **0-indexed** integer array `nums` and an integer `k`.
+
+Return _an integer that denotes the **sum** of elements in_ `nums` _whose corresponding **indices** have **exactly**_ `k` _set bits in their binary representation._
+
+The **set bits** in an integer are the `1`'s present when it is written in binary.
+
+* For example, the binary representation of `21` is `10101`, which has `3` set bits.
+
+**Example 1:**
+
+**Input:** nums = [5,10,1,5,2], k = 1
+
+**Output:** 13
+
+**Explanation:** The binary representation of the indices are: 
+
+0 = 000<sub>2</sub> 
+
+1 = 001<sub>2</sub> 
+
+2 = 010<sub>2</sub> 
+
+3 = 011<sub>2</sub> 
+
+4 = 100<sub>2</sub> 
+
+Indices 1, 2, and 4 have k = 1 set bits in their binary representation. Hence, the answer is nums[1] + nums[2] + nums[4] = 13.
+
+**Example 2:**
+
+**Input:** nums = [4,3,2,1], k = 2
+
+**Output:** 1
+
+**Explanation:** The binary representation of the indices are: 
+
+0 = 00<sub>2</sub> 
+
+1 = 01<sub>2</sub> 
+
+2 = 10<sub>2</sub> 
+
+3 = 11<sub>2</sub> 
+
+Only index 3 has k = 2 set bits in its binary representation. Hence, the answer is nums[3] = 1.
+
+**Constraints:**
+
+* `1 <= nums.length <= 1000`
+* <code>1 <= nums[i] <= 10<sup>5</sup></code>
+* `0 <= k <= 10`

src/main/java/g2801_2900/s2860_happy_students/Solution.java

@@ -0,0 +1,26 @@
+package g2801_2900.s2860_happy_students;
+
+// #Medium #Array #Sorting #Enumeration #2023_12_19_Time_33_ms_(91.76%)_Space_55.3_MB_(82.94%)
+
+import java.util.Collections;
+import java.util.List;
+
+public class Solution {
+ public int countWays(List<Integer> nums) {
+ Collections.sort(nums);
+ int cnt = 0;
+ int n = nums.size();
+ if (nums.get(0) != 0) {
+ cnt++;
+ }
+ for (int i = 0; i < n - 1; i++) {
+ if (nums.get(i) < (i + 1) && (nums.get(i + 1) > (i + 1))) {
+ cnt++;
+ }
+ }
+ if (n > nums.get(n - 1)) {
+ cnt++;
+ }
+ return cnt;
+ }
+}

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

@@ -0,0 +1,51 @@
+2860\. Happy Students
+
+Medium
+
+You are given a **0-indexed** integer array `nums` of length `n` where `n` is the total number of students in the class. The class teacher tries to select a group of students so that all the students remain happy.
+
+The <code>i<sup>th</sup></code> student will become happy if one of these two conditions is met:
+
+* The student is selected and the total number of selected students is **strictly greater than** `nums[i]`.
+* The student is not selected and the total number of selected students is **strictly** **less than** `nums[i]`.
+
+Return _the number of ways to select a group of students so that everyone remains happy._
+
+**Example 1:**
+
+**Input:** nums = [1,1]
+
+**Output:** 2
+
+**Explanation:** 
+
+The two possible ways are: 
+
+The class teacher selects no student. 
+
+The class teacher selects both students to form the group. 
+
+If the class teacher selects just one student to form a group then the both students will not be happy. 
+
+Therefore, there are only two possible ways.
+
+**Example 2:**
+
+**Input:** nums = [6,0,3,3,6,7,2,7]
+
+**Output:** 3
+
+**Explanation:** 
+
+The three possible ways are: 
+
+The class teacher selects the student with index = 1 to form the group. 
+
+The class teacher selects the students with index = 1, 2, 3, 6 to form the group. 
+
+The class teacher selects all the students to form the group.
+
+**Constraints:**
+
+* <code>1 <= nums.length <= 10<sup>5</sup></code>
+* `0 <= nums[i] < nums.length`