Added tasks 2358, 2359, 2360.

Author: javadev

README.md

@@ -1848,6 +1848,9 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2360 |[Longest Cycle in a Graph](src/main/java/g2301_2400/s2360_longest_cycle_in_a_graph/Solution.java)| Hard | Depth_First_Search, Graph, Topological_Sort | 37 | 90.19
+| 2359 |[Find Closest Node to Given Two Nodes](src/main/java/g2301_2400/s2359_find_closest_node_to_given_two_nodes/Solution.java)| Medium | Depth_First_Search, Graph | 18 | 89.33
+| 2358 |[Maximum Number of Groups Entering a Competition](src/main/java/g2301_2400/s2358_maximum_number_of_groups_entering_a_competition/Solution.java)| Medium | Array, Math, Binary_Search, Greedy | 0 | 100.00
 | 2357 |[Make Array Zero by Subtracting Equal Amounts](src/main/java/g2301_2400/s2357_make_array_zero_by_subtracting_equal_amounts/Solution.java)| Easy | Array, Hash_Table, Sorting, Heap_Priority_Queue, Simulation | 1 | 98.24
 | 2354 |[Number of Excellent Pairs](src/main/java/g2301_2400/s2354_number_of_excellent_pairs/Solution.java)| Hard | Array, Hash_Table, Binary_Search, Bit_Manipulation | 80 | 86.77
 | 2353 |[Design a Food Rating System](src/main/java/g2301_2400/s2353_design_a_food_rating_system/FoodRatings.java)| Medium | Hash_Table, Design, Heap_Priority_Queue, Ordered_Set | 364 | 83.35

src/main/java/g2301_2400/s2358_maximum_number_of_groups_entering_a_competition/Solution.java

@@ -0,0 +1,11 @@
+package g2301_2400.s2358_maximum_number_of_groups_entering_a_competition;
+
+// #Medium #Array #Math #Binary_Search #Greedy
+// #2022_08_14_Time_0_ms_(100.00%)_Space_70.5_MB_(27.33%)
+
+public class Solution {
+    public int maximumGroups(int[] grades) {
+        int len = grades.length;
+        return (int) (-1 + Math.sqrt(1D + 8 * len)) / 2;
+    }
+}

src/main/java/g2301_2400/s2358_maximum_number_of_groups_entering_a_competition/readme.md

@@ -0,0 +1,39 @@
+2358\. Maximum Number of Groups Entering a Competition
+
+Medium
+
+You are given a positive integer array `grades` which represents the grades of students in a university. You would like to enter **all** these students into a competition in **ordered** non-empty groups, such that the ordering meets the following conditions:
+
+*   The sum of the grades of students in the <code>i<sup>th</sup></code> group is **less than** the sum of the grades of students in the <code>(i + 1)<sup>th</sup></code> group, for all groups (except the last).
+*   The total number of students in the <code>i<sup>th</sup></code> group is **less than** the total number of students in the <code>(i + 1)<sup>th</sup></code> group, for all groups (except the last).
+
+Return _the **maximum** number of groups that can be formed_.
+
+**Example 1:**
+
+**Input:** grades = [10,6,12,7,3,5]
+
+**Output:** 3
+
+**Explanation:** The following is a possible way to form 3 groups of students:
+
+- 1<sup>st</sup> group has the students with grades = [12]. Sum of grades: 12. Student count: 1
+
+- 2<sup>nd</sup> group has the students with grades = [6,7]. Sum of grades: 6 + 7 = 13. Student count: 2
+
+- 3<sup>rd</sup> group has the students with grades = [10,3,5]. Sum of grades: 10 + 3 + 5 = 18. Student count: 3
+
+It can be shown that it is not possible to form more than 3 groups. 
+
+**Example 2:**
+
+**Input:** grades = [8,8]
+
+**Output:** 1
+
+**Explanation:** We can only form 1 group, since forming 2 groups would lead to an equal number of students in both groups. 
+
+**Constraints:**
+
+*   <code>1 <= grades.length <= 10<sup>5</sup></code>
+*   <code>1 <= grades[i] <= 10<sup>5</sup></code>

src/main/java/g2301_2400/s2359_find_closest_node_to_given_two_nodes/Solution.java

@@ -0,0 +1,30 @@
+package g2301_2400.s2359_find_closest_node_to_given_two_nodes;
+
+// #Medium #Depth_First_Search #Graph #2022_08_14_Time_18_ms_(89.33%)_Space_112.3_MB_(69.17%)
+
+public class Solution {
+    public int closestMeetingNode(int[] edges, int node1, int node2) {
+        final int n = edges.length;
+        final Integer[] m1 = new Integer[n];
+        final Integer[] m2 = new Integer[n];
+        dfs(edges, m1, node1);
+        dfs(edges, m2, node2);
+        int index = -1;
+        int dist = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (m1[i] != null && m2[i] != null && dist > Math.max(m1[i], m2[i])) {
+                dist = Math.max(m1[i], m2[i]);
+                index = i;
+            }
+        }
+        return index;
+    }
+
+    private void dfs(int[] edges, Integer[] memo, int node) {
+        int dist = 0;
+        while (node != -1 && memo[node] == null) {
+            memo[node] = dist++;
+            node = edges[node];
+        }
+    }
+}

src/main/java/g2301_2400/s2359_find_closest_node_to_given_two_nodes/readme.md

@@ -0,0 +1,45 @@
+2359\. Find Closest Node to Given Two Nodes
+
+Medium
+
+You are given a **directed** graph of `n` nodes numbered from `0` to `n - 1`, where each node has **at most one** outgoing edge.
+
+The graph is represented with a given **0-indexed** array `edges` of size `n`, indicating that there is a directed edge from node `i` to node `edges[i]`. If there is no outgoing edge from `i`, then `edges[i] == -1`.
+
+You are also given two integers `node1` and `node2`.
+
+Return _the **index** of the node that can be reached from both_ `node1` _and_ `node2`_, such that the **maximum** between the distance from_ `node1` _to that node, and from_ `node2` _to that node is **minimized**_. If there are multiple answers, return the node with the **smallest** index, and if no possible answer exists, return `-1`.
+
+Note that `edges` may contain cycles.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/06/07/graph4drawio-2.png)
+
+**Input:** edges = [2,2,3,-1], node1 = 0, node2 = 1
+
+**Output:** 2
+
+**Explanation:** The distance from node 0 to node 2 is 1, and the distance from node 1 to node 2 is 1.
+
+The maximum of those two distances is 1. It can be proven that we cannot get a node with a smaller maximum distance than 1, so we return node 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/06/07/graph4drawio-4.png)
+
+**Input:** edges = [1,2,-1], node1 = 0, node2 = 2
+
+**Output:** 2
+
+**Explanation:** The distance from node 0 to node 2 is 2, and the distance from node 2 to itself is 0.
+
+The maximum of those two distances is 2. It can be proven that we cannot get a node with a smaller maximum distance than 2, so we return node 2.
+
+**Constraints:**
+
+*   `n == edges.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `-1 <= edges[i] < n`
+*   `edges[i] != i`
+*   `0 <= node1, node2 < n`

src/main/java/g2301_2400/s2360_longest_cycle_in_a_graph/Solution.java

@@ -0,0 +1,36 @@
+package g2301_2400.s2360_longest_cycle_in_a_graph;
+
+// #Hard #Depth_First_Search #Graph #Topological_Sort
+// #2022_08_14_Time_37_ms_(90.19%)_Space_102.8_MB_(72.92%)
+
+public class Solution {
+    public int longestCycle(int[] edges) {
+        int n = edges.length;
+        boolean[] vis = new boolean[n];
+        boolean[] dfsvis = new boolean[n];
+        int[] path = new int[n];
+        int maxLength = -1;
+        for (int i = 0; i < n; i++) {
+            if (!vis[i]) {
+                path[i] = 1;
+                maxLength = Math.max(maxLength, dfs(i, 1, path, vis, dfsvis, edges));
+            }
+        }
+        return maxLength;
+    }
+
+    private int dfs(
+            int node, int pathLength, int[] path, boolean[] vis, boolean[] dfsvis, int[] edges) {
+        vis[node] = true;
+        dfsvis[node] = true;
+        int length = -1;
+        if (edges[node] != -1 && !vis[edges[node]]) {
+            path[edges[node]] = pathLength + 1;
+            length = dfs(edges[node], pathLength + 1, path, vis, dfsvis, edges);
+        } else if (edges[node] != -1 && dfsvis[edges[node]]) {
+            length = pathLength - path[edges[node]] + 1;
+        }
+        dfsvis[node] = false;
+        return length;
+    }
+}

src/main/java/g2301_2400/s2360_longest_cycle_in_a_graph/readme.md

@@ -0,0 +1,40 @@
+2360\. Longest Cycle in a Graph
+
+Hard
+
+You are given a **directed** graph of `n` nodes numbered from `0` to `n - 1`, where each node has **at most one** outgoing edge.
+
+The graph is represented with a given **0-indexed** array `edges` of size `n`, indicating that there is a directed edge from node `i` to node `edges[i]`. If there is no outgoing edge from node `i`, then `edges[i] == -1`.
+
+Return _the length of the **longest** cycle in the graph_. If no cycle exists, return `-1`.
+
+A cycle is a path that starts and ends at the **same** node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/06/08/graph4drawio-5.png)
+
+**Input:** edges = [3,3,4,2,3]
+
+**Output:** 3
+
+**Explanation:** The longest cycle in the graph is the cycle: 2 -> 4 -> 3 -> 2.
+
+The length of this cycle is 3, so 3 is returned. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/06/07/graph4drawio-1.png)
+
+**Input:** edges = [2,-1,3,1]
+
+**Output:** -1
+
+**Explanation:** There are no cycles in this graph. 
+
+**Constraints:**
+
+*   `n == edges.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `-1 <= edges[i] < n`
+*   `edges[i] != i`

src/test/java/g2301_2400/s2358_maximum_number_of_groups_entering_a_competition/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2358_maximum_number_of_groups_entering_a_competition;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximumGroups() {
+        assertThat(new Solution().maximumGroups(new int[] {10, 6, 12, 7, 3, 5}), equalTo(3));
+    }
+
+    @Test
+    void maximumGroups2() {
+        assertThat(new Solution().maximumGroups(new int[] {8, 8}), equalTo(1));
+    }
+}

src/test/java/g2301_2400/s2359_find_closest_node_to_given_two_nodes/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2359_find_closest_node_to_given_two_nodes;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void closestMeetingNode() {
+        assertThat(new Solution().closestMeetingNode(new int[] {2, 2, 3, -1}, 0, 1), equalTo(2));
+    }
+
+    @Test
+    void closestMeetingNode2() {
+        assertThat(new Solution().closestMeetingNode(new int[] {1, 2, -1}, 0, 2), equalTo(2));
+    }
+}

src/test/java/g2301_2400/s2360_longest_cycle_in_a_graph/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2360_longest_cycle_in_a_graph;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void longestCycle() {
+        assertThat(new Solution().longestCycle(new int[] {3, 3, 4, 2, 3}), equalTo(3));
+    }
+
+    @Test
+    void longestCycle2() {
+        assertThat(new Solution().longestCycle(new int[] {2, -1, 3, 1}), equalTo(-1));
+    }
+}