Added tasks 2091, 2092.

Author: javadev

src/main/java/g2001_2100/s2091_removing_minimum_and_maximum_from_array/Solution.java

@@ -0,0 +1,36 @@
+package g2001_2100.s2091_removing_minimum_and_maximum_from_array;
+
+// #Medium #Array #Greedy #2022_05_27_Time_2_ms_(100.00%)_Space_84.4_MB_(40.48%)
+
+public class Solution {
+    public int minimumDeletions(int[] nums) {
+        int n = nums.length;
+        int min = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        int minIndex = 0;
+        int maxIndex = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] < min) {
+                min = nums[i];
+                minIndex = i;
+            }
+            if (nums[i] > max) {
+                max = nums[i];
+                maxIndex = i;
+            }
+        }
+        int firstCase = 0;
+        int secondCase = 0;
+        int thirdCase = 0;
+        if (minIndex > maxIndex) {
+            firstCase = minIndex + 1;
+            secondCase = n - maxIndex;
+            thirdCase = maxIndex + 1 + (n - minIndex);
+        } else {
+            firstCase = maxIndex + 1;
+            secondCase = n - minIndex;
+            thirdCase = minIndex + 1 + (n - maxIndex);
+        }
+        return Math.min(firstCase, Math.min(secondCase, thirdCase));
+    }
+}

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

@@ -0,0 +1,61 @@
+2091\. Removing Minimum and Maximum From Array
+
+Medium
+
+You are given a **0-indexed** array of **distinct** integers `nums`.
+
+There is an element in `nums` that has the **lowest** value and an element that has the **highest** value. We call them the **minimum** and **maximum** respectively. Your goal is to remove **both** these elements from the array.
+
+A **deletion** is defined as either removing an element from the **front** of the array or removing an element from the **back** of the array.
+
+Return _the **minimum** number of deletions it would take to remove **both** the minimum and maximum element from the array._
+
+**Example 1:**
+
+**Input:** nums = [2,**10**,7,5,4,**1**,8,6]
+
+**Output:** 5
+
+**Explanation:**
+
+The minimum element in the array is nums[5], which is 1.
+
+The maximum element in the array is nums[1], which is 10.
+
+We can remove both the minimum and maximum by removing 2 elements from the front and 3 elements from the back.
+
+This results in 2 + 3 = 5 deletions, which is the minimum number possible. 
+
+**Example 2:**
+
+**Input:** nums = [0,**\-4**,**19**,1,8,-2,-3,5]
+
+**Output:** 3
+
+**Explanation:**
+
+The minimum element in the array is nums[1], which is -4.
+
+The maximum element in the array is nums[2], which is 19.
+
+We can remove both the minimum and maximum by removing 3 elements from the front.
+
+This results in only 3 deletions, which is the minimum number possible. 
+
+**Example 3:**
+
+**Input:** nums = [**101**]
+
+**Output:** 1
+
+**Explanation:**
+
+There is only one element in the array, which makes it both the minimum and maximum element.
+
+We can remove it with 1 deletion. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+*   The integers in `nums` are **distinct**.

src/main/java/g2001_2100/s2092_find_all_people_with_secret/Solution.java

@@ -0,0 +1,93 @@
+package g2001_2100.s2092_find_all_people_with_secret;
+
+// #Hard #Depth_First_Search #Sorting #Breadth_First_Search #Graph #Union_Find
+// #2022_05_27_Time_95_ms_(84.86%)_Space_99.7_MB_(87.33%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution {
+    public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
+        Arrays.sort(meetings, ((a, b) -> a[2] - b[2]));
+        UF uf = new UF(n);
+        // base
+        uf.union(0, firstPerson);
+        // for every time we have a pool of people that talk to each other
+        // if someone knows a secret proir to this meeting - all pool will too
+        // if not - reset unions from this pool
+        int i = 0;
+        while (i < meetings.length) {
+            int curTime = meetings[i][2];
+            Set<Integer> pool = new HashSet<>();
+            while (i < meetings.length && curTime == meetings[i][2]) {
+                int[] currentMeeting = meetings[i];
+                uf.union(currentMeeting[0], currentMeeting[1]);
+                pool.add(currentMeeting[0]);
+                pool.add(currentMeeting[1]);
+                i++;
+            }
+            // meeting that took place now should't affect future
+            // meetings if people don't know the secret
+            for (int j : pool) {
+                if (!uf.connected(0, j)) {
+                    uf.reset(j);
+                }
+            }
+        }
+        // if the person is conneted to 0 - they know a secret
+        List<Integer> ans = new ArrayList<>();
+        for (int j = 0; j < n; j++) {
+            if (uf.connected(j, 0)) {
+                ans.add(j);
+            }
+        }
+        return ans;
+    }
+
+    // regular union find
+    private static class UF {
+        private int[] parent;
+        private int[] rank;
+
+        public UF(int n) {
+            parent = new int[n];
+            rank = new int[n];
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
+        }
+
+        public void union(int p, int q) {
+            int rootP = find(p);
+            int rootQ = find(q);
+            if (rootP == rootQ) {
+                return;
+            }
+            if (rank[rootP] < rank[rootQ]) {
+                parent[rootP] = rootQ;
+            } else {
+                parent[rootQ] = rootP;
+                rank[rootP]++;
+            }
+        }
+
+        public int find(int p) {
+            while (parent[p] != p) {
+                p = parent[parent[p]];
+            }
+            return p;
+        }
+
+        public boolean connected(int p, int q) {
+            return find(p) == find(q);
+        }
+
+        public void reset(int p) {
+            parent[p] = p;
+            rank[p] = 0;
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+2092\. Find All People With Secret
+
+Hard
+
+You are given an integer `n` indicating there are `n` people numbered from `0` to `n - 1`. You are also given a **0-indexed** 2D integer array `meetings` where <code>meetings[i] = [x<sub>i</sub>, y<sub>i</sub>, time<sub>i</sub>]</code> indicates that person <code>x<sub>i</sub></code> and person <code>y<sub>i</sub></code> have a meeting at <code>time<sub>i</sub></code>. A person may attend **multiple meetings** at the same time. Finally, you are given an integer `firstPerson`.
+
+Person `0` has a **secret** and initially shares the secret with a person `firstPerson` at time `0`. This secret is then shared every time a meeting takes place with a person that has the secret. More formally, for every meeting, if a person <code>x<sub>i</sub></code> has the secret at <code>time<sub>i</sub></code>, then they will share the secret with person <code>y<sub>i</sub></code>, and vice versa.
+
+The secrets are shared **instantaneously**. That is, a person may receive the secret and share it with people in other meetings within the same time frame.
+
+Return _a list of all the people that have the secret after all the meetings have taken place._ You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** n = 6, meetings = [[1,2,5],[2,3,8],[1,5,10]], firstPerson = 1
+
+**Output:** [0,1,2,3,5]
+
+**Explanation:**
+
+At time 0, person 0 shares the secret with person 1.
+
+At time 5, person 1 shares the secret with person 2.
+
+At time 8, person 2 shares the secret with person 3.
+
+At time 10, person 1 shares the secret with person 5.
+
+Thus, people 0, 1, 2, 3, and 5 know the secret after all the meetings. 
+
+**Example 2:**
+
+**Input:** n = 4, meetings = [[3,1,3],[1,2,2],[0,3,3]], firstPerson = 3
+
+**Output:** [0,1,3]
+
+**Explanation:**
+
+At time 0, person 0 shares the secret with person 3.
+
+At time 2, neither person 1 nor person 2 know the secret.
+
+At time 3, person 3 shares the secret with person 0 and person 1.
+
+Thus, people 0, 1, and 3 know the secret after all the meetings. 
+
+**Example 3:**
+
+**Input:** n = 5, meetings = [[3,4,2],[1,2,1],[2,3,1]], firstPerson = 1
+
+**Output:** [0,1,2,3,4]
+
+**Explanation:**
+
+At time 0, person 0 shares the secret with person 1.
+
+At time 1, person 1 shares the secret with person 2, and person 2 shares the secret with person 3.
+
+Note that person 2 can share the secret at the same time as receiving it.
+
+At time 2, person 3 shares the secret with person 4.
+
+Thus, people 0, 1, 2, 3, and 4 know the secret after all the meetings. 
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= meetings.length <= 10<sup>5</sup></code>
+*   `meetings[i].length == 3`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= n - 1</code>
+*   <code>x<sub>i</sub> != y<sub>i</sub></code>
+*   <code>1 <= time<sub>i</sub> <= 10<sup>5</sup></code>
+*   `1 <= firstPerson <= n - 1`

src/test/java/g2001_2100/s2091_removing_minimum_and_maximum_from_array/SolutionTest.java

@@ -0,0 +1,26 @@
+package g2001_2100.s2091_removing_minimum_and_maximum_from_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumDeletions() {
+        assertThat(
+                new Solution().minimumDeletions(new int[] {2, 10, 7, 5, 4, 1, 8, 6}), equalTo(5));
+    }
+
+    @Test
+    void minimumDeletions2() {
+        assertThat(
+                new Solution().minimumDeletions(new int[] {0, -4, 19, 1, 8, -2, -3, 5}),
+                equalTo(3));
+    }
+
+    @Test
+    void minimumDeletions3() {
+        assertThat(new Solution().minimumDeletions(new int[] {101}), equalTo(1));
+    }
+}

src/test/java/g2001_2100/s2092_find_all_people_with_secret/SolutionTest.java

@@ -0,0 +1,30 @@
+package g2001_2100.s2092_find_all_people_with_secret;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findAllPeople() {
+        assertThat(
+                new Solution().findAllPeople(6, new int[][] {{1, 2, 5}, {2, 3, 8}, {1, 5, 10}}, 1),
+                equalTo(Arrays.asList(0, 1, 2, 3, 5)));
+    }
+
+    @Test
+    void findAllPeople2() {
+        assertThat(
+                new Solution().findAllPeople(4, new int[][] {{3, 1, 3}, {1, 2, 2}, {0, 3, 3}}, 3),
+                equalTo(Arrays.asList(0, 1, 3)));
+    }
+
+    @Test
+    void findAllPeople3() {
+        assertThat(
+                new Solution().findAllPeople(5, new int[][] {{3, 4, 2}, {1, 2, 1}, {2, 3, 1}}, 1),
+                equalTo(Arrays.asList(0, 1, 2, 3, 4)));
+    }
+}