Added tasks 2497, 2498, 2499, 2500

Author: javadev

README.md

@@ -1848,6 +1848,10 @@ implementation 'com.github.javadev:leetcode-in-java:1.18'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2500 |[Delete Greatest Value in Each Row](src/main/java/g2401_2500/s2500_delete_greatest_value_in_each_row/Solution.java)| Easy | Array, Sorting, Matrix | 3 | 98.16
+| 2499 |[Minimum Total Cost to Make Arrays Unequal](src/main/java/g2401_2500/s2499_minimum_total_cost_to_make_arrays_unequal/Solution.java)| Hard | Array, Hash_Table, Greedy, Counting | 3 | 100.00
+| 2498 |[Frog Jump II](src/main/java/g2401_2500/s2498_frog_jump_ii/Solution.java)| Medium | Array, Greedy, Binary_Search | 1 | 100.00
+| 2497 |[Maximum Star Sum of a Graph](src/main/java/g2401_2500/s2497_maximum_star_sum_of_a_graph/Solution.java)| Medium | Array, Sorting, Greedy, Heap_Priority_Queue, Graph | 36 | 97.50
 | 2496 |[Maximum Value of a String in an Array](src/main/java/g2401_2500/s2496_maximum_value_of_a_string_in_an_array/Solution.java)| Easy | Array, String | 1 | 92.00
 | 2493 |[Divide Nodes Into the Maximum Number of Groups](src/main/java/g2401_2500/s2493_divide_nodes_into_the_maximum_number_of_groups/Solution.java)| Hard | Breadth_First_Search, Graph, Union_Find | 443 | 77.02
 | 2492 |[Minimum Score of a Path Between Two Cities](src/main/java/g2401_2500/s2492_minimum_score_of_a_path_between_two_cities/Solution.java)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 13 | 92.82

src/main/java/g2401_2500/s2497_maximum_star_sum_of_a_graph/Solution.java

@@ -0,0 +1,46 @@
+package g2401_2500.s2497_maximum_star_sum_of_a_graph;
+
+// #Medium #Array #Sorting #Greedy #Heap_Priority_Queue #Graph
+// #2023_02_12_Time_36_ms_(97.50%)_Space_90.1_MB_(69.28%)
+
+import java.util.PriorityQueue;
+
+public class Solution {
+    private PriorityQueue<Integer>[] graphNodeIdToNodeValues;
+
+    public int maxStarSum(int[] nodeValues, int[][] edges, int maxNumberOfEdges) {
+        final int totalNodes = nodeValues.length;
+        graphNodeIdToNodeValues = new PriorityQueue[totalNodes];
+        for (int i = 0; i < totalNodes; ++i) {
+            graphNodeIdToNodeValues[i] = new PriorityQueue<>();
+        }
+        for (int[] edge : edges) {
+            addEdgeEndingWithValueOfNode(nodeValues, edge[0], edge[1], maxNumberOfEdges);
+            addEdgeEndingWithValueOfNode(nodeValues, edge[1], edge[0], maxNumberOfEdges);
+        }
+        return calculateMaxStarSum(nodeValues, totalNodes);
+    }
+
+    private void addEdgeEndingWithValueOfNode(
+            int[] nodeValues, int fromNode, int toNode, int maxNumberOfEdges) {
+        if (nodeValues[toNode] > 0 && graphNodeIdToNodeValues[fromNode].size() < maxNumberOfEdges) {
+            graphNodeIdToNodeValues[fromNode].add(nodeValues[toNode]);
+        } else if (!graphNodeIdToNodeValues[fromNode].isEmpty()
+                && graphNodeIdToNodeValues[fromNode].peek() < nodeValues[toNode]) {
+            graphNodeIdToNodeValues[fromNode].poll();
+            graphNodeIdToNodeValues[fromNode].add(nodeValues[toNode]);
+        }
+    }
+
+    private int calculateMaxStarSum(int[] nodeValues, int totalNodes) {
+        int maxStarSum = Integer.MIN_VALUE;
+        for (int i = 0; i < totalNodes; ++i) {
+            int sum = nodeValues[i];
+            for (int value : graphNodeIdToNodeValues[i]) {
+                sum += value;
+            }
+            maxStarSum = Math.max(maxStarSum, sum);
+        }
+        return maxStarSum;
+    }
+}

src/main/java/g2401_2500/s2497_maximum_star_sum_of_a_graph/readme.md

@@ -0,0 +1,50 @@
+2497\. Maximum Star Sum of a Graph
+
+Medium
+
+There is an undirected graph consisting of `n` nodes numbered from `0` to `n - 1`. You are given a **0-indexed** integer array `vals` of length `n` where `vals[i]` denotes the value of the <code>i<sup>th</sup></code> node.
+
+You are also given a 2D integer array `edges` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an **undirected** edge connecting nodes <code>a<sub>i</sub></code> and <code>b<sub>i.</sub></code>
+
+A **star graph** is a subgraph of the given graph having a center node containing `0` or more neighbors. In other words, it is a subset of edges of the given graph such that there exists a common node for all edges.
+
+The image below shows star graphs with `3` and `4` neighbors respectively, centered at the blue node.
+
+![](https://assets.leetcode.com/uploads/2022/11/07/max-star-sum-descdrawio.png)
+
+The **star sum** is the sum of the values of all the nodes present in the star graph.
+
+Given an integer `k`, return _the **maximum star sum** of a star graph containing **at most**_ `k` _edges._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/11/07/max-star-sum-example1drawio.png)
+
+**Input:** vals = [1,2,3,4,10,-10,-20], edges = [[0,1],[1,2],[1,3],[3,4],[3,5],[3,6]], k = 2
+
+**Output:** 16
+
+**Explanation:** The above diagram represents the input graph.
+
+The star graph with the maximum star sum is denoted by blue.
+
+It is centered at 3 and includes its neighbors 1 and 4. It can be shown it is not possible to get a star graph with a sum greater than 16. 
+
+**Example 2:**
+
+**Input:** vals = [-5], edges = [], k = 0
+
+**Output:** -5
+
+**Explanation:** There is only one possible star graph, which is node 0 itself. Hence, we return -5. 
+
+**Constraints:**
+
+*   `n == vals.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= vals[i] <= 10<sup>4</sup></code>
+*   `0 <= edges.length <= min(n * (n - 1) / 2`<code>, 10<sup>5</sup>)</code>
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   `0 <= k <= n - 1`

src/main/java/g2401_2500/s2498_frog_jump_ii/Solution.java

@@ -0,0 +1,21 @@
+package g2401_2500.s2498_frog_jump_ii;
+
+// #Medium #Array #Greedy #Binary_Search #2023_02_12_Time_1_ms_(100.00%)_Space_55.8_MB_(66.50%)
+
+public class Solution {
+    public int maxJump(int[] stones) {
+        int n = stones.length;
+        int max = 0;
+        for (int i = 2; i < n; i++) {
+            int gap = stones[i] - stones[i - 2];
+            if (gap > max) {
+                max = gap;
+            }
+        }
+        if (n > 2) {
+            return max;
+        } else {
+            return stones[1] - stones[0];
+        }
+    }
+}

src/main/java/g2401_2500/s2498_frog_jump_ii/readme.md

@@ -0,0 +1,50 @@
+2498\. Frog Jump II
+
+Medium
+
+You are given a **0-indexed** integer array `stones` sorted in **strictly increasing order** representing the positions of stones in a river.
+
+A frog, initially on the first stone, wants to travel to the last stone and then return to the first stone. However, it can jump to any stone **at most once**.
+
+The **length** of a jump is the absolute difference between the position of the stone the frog is currently on and the position of the stone to which the frog jumps.
+
+*   More formally, if the frog is at `stones[i]` and is jumping to `stones[j]`, the length of the jump is `|stones[i] - stones[j]|`.
+
+The **cost** of a path is the **maximum length of a jump** among all jumps in the path.
+
+Return _the **minimum** cost of a path for the frog_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/11/14/example-1.png)
+
+**Input:** stones = [0,2,5,6,7]
+
+**Output:** 5
+
+**Explanation:** The above figure represents one of the optimal paths the frog can take.
+
+The cost of this path is 5, which is the maximum length of a jump.
+
+Since it is not possible to achieve a cost of less than 5, we return it. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/11/14/example-2.png)
+
+**Input:** stones = [0,3,9]
+
+**Output:** 9
+
+**Explanation:** The frog can jump directly to the last stone and come back to the first stone.
+
+In this case, the length of each jump will be 9. The cost for the path will be max(9, 9) = 9.
+
+It can be shown that this is the minimum achievable cost. 
+
+**Constraints:**
+
+*   <code>2 <= stones.length <= 10<sup>5</sup></code>
+*   <code>0 <= stones[i] <= 10<sup>9</sup></code>
+*   `stones[0] == 0`
+*   `stones` is sorted in a strictly increasing order.

src/main/java/g2401_2500/s2499_minimum_total_cost_to_make_arrays_unequal/Solution.java

@@ -0,0 +1,43 @@
+package g2401_2500.s2499_minimum_total_cost_to_make_arrays_unequal;
+
+// #Hard #Array #Hash_Table #Greedy #Counting #2023_02_12_Time_3_ms_(100.00%)_Space_59.5_MB_(76.40%)
+
+public class Solution {
+    public long minimumTotalCost(int[] nums1, int[] nums2) {
+        int n = nums1.length;
+        int[] bucket = new int[n + 1];
+        int max = 0;
+        int maxKey = -1;
+        int totalBucket = 0;
+        long cost = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums1[i] == nums2[i]) {
+                if (++bucket[nums1[i]] > max) {
+                    max = bucket[nums1[i]];
+                    maxKey = nums1[i];
+                }
+                totalBucket++;
+                cost += i;
+            }
+        }
+        int requiredBucket = 2 * max;
+        if (requiredBucket > n) {
+            return -1;
+        }
+        int lackBucket = requiredBucket - totalBucket;
+        int i = 0;
+        while (i < n && lackBucket > 0) {
+            if (nums1[i] == maxKey || nums2[i] == maxKey || nums1[i] == nums2[i]) {
+                i++;
+                continue;
+            }
+            lackBucket--;
+            cost += i;
+            i++;
+        }
+        if (lackBucket > 0) {
+            return -1;
+        }
+        return cost;
+    }
+}

src/main/java/g2401_2500/s2499_minimum_total_cost_to_make_arrays_unequal/readme.md

@@ -0,0 +1,57 @@
+2499\. Minimum Total Cost to Make Arrays Unequal
+
+Hard
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2`, of equal length `n`.
+
+In one operation, you can swap the values of any two indices of `nums1`. The **cost** of this operation is the **sum** of the indices.
+
+Find the **minimum** total cost of performing the given operation **any** number of times such that `nums1[i] != nums2[i]` for all `0 <= i <= n - 1` after performing all the operations.
+
+Return _the **minimum total cost** such that_ `nums1` and `nums2` _satisfy the above condition_. In case it is not possible, return `-1`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3,4,5], nums2 = [1,2,3,4,5]
+
+**Output:** 10
+
+**Explanation:** One of the ways we can perform the operations is:
+
+- Swap values at indices 0 and 3, incurring cost = 0 + 3 = 3. Now, nums1 = [4,2,3,1,5]
+
+- Swap values at indices 1 and 2, incurring cost = 1 + 2 = 3. Now, nums1 = [4,3,2,1,5].
+
+- Swap values at indices 0 and 4, incurring cost = 0 + 4 = 4. Now, nums1 =[5,3,2,1,4].
+
+We can see that for each index i, nums1[i] != nums2[i]. The cost required here is 10.
+
+Note that there are other ways to swap values, but it can be proven that it is not possible to obtain a cost less than 10. 
+
+**Example 2:**
+
+**Input:** nums1 = [2,2,2,1,3], nums2 = [1,2,2,3,3]
+
+**Output:** 10
+
+**Explanation:** One of the ways we can perform the operations is:
+
+- Swap values at indices 2 and 3, incurring cost = 2 + 3 = 5. Now, nums1 = [2,2,1,2,3].
+
+- Swap values at indices 1 and 4, incurring cost = 1 + 4 = 5. Now, nums1 = [2,3,1,2,2].
+
+The total cost needed here is 10, which is the minimum possible. 
+
+**Example 3:**
+
+**Input:** nums1 = [1,2,2], nums2 = [1,2,2]
+
+**Output:** -1
+
+**Explanation:** It can be shown that it is not possible to satisfy the given conditions irrespective of the number of operations we perform. Hence, we return -1. 
+
+**Constraints:**
+
+*   `n == nums1.length == nums2.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= nums1[i], nums2[i] <= n`

src/main/java/g2401_2500/s2500_delete_greatest_value_in_each_row/Solution.java

@@ -0,0 +1,24 @@
+package g2401_2500.s2500_delete_greatest_value_in_each_row;
+
+// #Easy #Array #Sorting #Matrix #2023_02_12_Time_3_ms_(98.16%)_Space_42.6_MB_(34.09%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int deleteGreatestValue(int[][] grid) {
+        int sum = 0;
+        for (int i = 0; i < grid.length; i++) {
+            Arrays.sort(grid[i]);
+        }
+        for (int j = 0; j < grid[0].length; j++) {
+            int max = Integer.MIN_VALUE;
+            for (int i = 0; i < grid.length; i++) {
+                if (grid[i][j] > max) {
+                    max = grid[i][j];
+                }
+            }
+            sum += max;
+        }
+        return sum;
+    }
+}

src/main/java/g2401_2500/s2500_delete_greatest_value_in_each_row/readme.md

@@ -0,0 +1,53 @@
+2500\. Delete Greatest Value in Each Row
+
+Easy
+
+You are given an `m x n` matrix `grid` consisting of positive integers.
+
+Perform the following operation until `grid` becomes empty:
+
+*   Delete the element with the greatest value from each row. If multiple such elements exist, delete any of them.
+*   Add the maximum of deleted elements to the answer.
+
+**Note** that the number of columns decreases by one after each operation.
+
+Return _the answer after performing the operations described above_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/19/q1ex1.jpg)
+
+**Input:** grid = [[1,2,4],[3,3,1]]
+
+**Output:** 8
+
+**Explanation:** The diagram above shows the removed values in each step.
+
+- In the first operation, we remove 4 from the first row and 3 from the second row (notice that, there are two cells with value 3 and we can remove any of them). We add 4 to the answer.
+
+- In the second operation, we remove 2 from the first row and 3 from the second row. We add 3 to the answer.
+
+- In the third operation, we remove 1 from the first row and 1 from the second row. We add 1 to the answer.
+
+The final answer = 4 + 3 + 1 = 8. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/10/19/q1ex2.jpg)
+
+**Input:** grid = [[10]]
+
+**Output:** 10
+
+**Explanation:** The diagram above shows the removed values in each step.
+
+- In the first operation, we remove 10 from the first row. We add 10 to the answer.
+
+The final answer = 10. 
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 50`
+*   `1 <= grid[i][j] <= 100`

src/test/java/g2401_2500/s2497_maximum_star_sum_of_a_graph/SolutionTest.java

@@ -0,0 +1,24 @@
+package g2401_2500.s2497_maximum_star_sum_of_a_graph;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxStarSum() {
+        assertThat(
+                new Solution()
+                        .maxStarSum(
+                                new int[] {1, 2, 3, 4, 10, -10, -20},
+                                new int[][] {{0, 1}, {1, 2}, {1, 3}, {3, 4}, {3, 5}, {3, 6}},
+                                2),
+                equalTo(16));
+    }
+
+    @Test
+    void maxStarSum2() {
+        assertThat(new Solution().maxStarSum(new int[] {-5}, new int[][] {}, 0), equalTo(-5));
+    }
+}