Added task 2542

Author: javadev

README.md

@@ -1848,9 +1848,10 @@ implementation 'com.github.javadev:leetcode-in-java:1.21'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2542 |[Maximum Subsequence Score](src/main/java/g2501_2600/s2542_maximum_subsequence_score/Solution.java)| Medium | Array, Sorting, Greedy, Heap_(Priority_Queue) | 94 | 84.75
 | 2541 |[Minimum Operations to Make Array Equal II](src/main/java/g2501_2600/s2541_minimum_operations_to_make_array_equal_ii/Solution.java)| Medium | Array, Math, Greedy | 3 | 100.00
 | 2540 |[Minimum Common Value](src/main/java/g2501_2600/s2540_minimum_common_value/Solution.java)| Easy | Array, Hash_Table, Binary_Search, Two_Pointers | 0 | 100.00
-| 2538 |[Difference Between Maximum and Minimum Price Sum](src/main/java/g2501_2600/s2538_difference_between_maximum_and_minimum_price_sum/Solution.java)| Hard | Array, Dynamic_Programming, Tree, Depth_First_Search | 43 | 95.19
+| 2538 |[Difference Between Maximum and Minimum Price Sum](src/main/java/g2501_2600/s2538_difference_between_maximum_and_minimum_price_sum/Solution.java)| Hard | Array, Dynamic_Programming, Depth_First_Search, Tree | 43 | 95.19
 | 2537 |[Count the Number of Good Subarrays](src/main/java/g2501_2600/s2537_count_the_number_of_good_subarrays/Solution.java)| Medium | Array, Hash_Table, Sliding_Window | 38 | 99.07
 | 2536 |[Increment Submatrices by One](src/main/java/g2501_2600/s2536_increment_submatrices_by_one/Solution.java)| Medium | Array, Matrix, Prefix_Sum | 12 | 88.15
 | 2535 |[Difference Between Element Sum and Digit Sum of an Array](src/main/java/g2501_2600/s2535_difference_between_element_sum_and_digit_sum_of_an_array/Solution.java)| Easy | Array, Math | 3 | 77.42

src/main/java/g2501_2600/s2542_maximum_subsequence_score/Solution.java

@@ -0,0 +1,50 @@
+package g2501_2600.s2542_maximum_subsequence_score;
+
+// #Medium #Array #Sorting #Greedy #Heap_(Priority_Queue)
+// #2023_05_09_Time_94_ms_(84.75%)_Space_56.5_MB_(81.92%)
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Solution {
+    private static class PairInfo {
+        int val1;
+        int val2;
+
+        public PairInfo(int val1, int val2) {
+            this.val1 = val1;
+            this.val2 = val2;
+        }
+    }
+
+    public long maxScore(int[] nums1, int[] nums2, int k) {
+        int n = nums1.length;
+        PairInfo[] nums = new PairInfo[n];
+        for (int i = 0; i < n; ++i) {
+            nums[i] = new PairInfo(nums1[i], nums2[i]);
+        }
+        Arrays.sort(
+                nums,
+                (a, b) -> {
+                    if (a.val2 == b.val2) {
+                        return a.val1 - b.val1;
+                    }
+                    return a.val2 - b.val2;
+                });
+        long sum = 0;
+        long ans = 0;
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for (int i = n - 1; i >= 0; --i) {
+            int minVal = nums[i].val2;
+            while (pq.size() > k - 1) {
+                sum -= pq.poll();
+            }
+            sum += nums[i].val1;
+            pq.add(nums[i].val1);
+            if (pq.size() == k) {
+                ans = Math.max(ans, sum * minVal);
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2501_2600/s2542_maximum_subsequence_score/readme.md

@@ -0,0 +1,49 @@
+2542\. Maximum Subsequence Score
+
+Medium
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2` of equal length `n` and a positive integer `k`. You must choose a **subsequence** of indices from `nums1` of length `k`.
+
+For chosen indices <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, ..., <code>i<sub>k - 1</sub></code>, your **score** is defined as:
+
+*   The sum of the selected elements from `nums1` multiplied with the **minimum** of the selected elements from `nums2`.
+*   It can defined simply as: <code>(nums1[i<sub>0</sub>] + nums1[i<sub>1</sub>] +...+ nums1[i<sub>k - 1</sub>]) * min(nums2[i<sub>0</sub>] , nums2[i<sub>1</sub>], ... ,nums2[i<sub>k - 1</sub>])</code>.
+
+Return _the **maximum** possible score._
+
+A **subsequence** of indices of an array is a set that can be derived from the set `{0, 1, ..., n-1}` by deleting some or no elements.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3,3,2], nums2 = [2,1,3,4], k = 3
+
+**Output:** 12
+
+**Explanation:**
+
+The four possible subsequence scores are:
+
+- We choose the indices 0, 1, and 2 with score = (1+3+3) \* min(2,1,3) = 7.
+
+- We choose the indices 0, 1, and 3 with score = (1+3+2) \* min(2,1,4) = 6.
+
+- We choose the indices 0, 2, and 3 with score = (1+3+2) \* min(2,3,4) = 12.
+
+- We choose the indices 1, 2, and 3 with score = (3+3+2) \* min(1,3,4) = 8.
+
+Therefore, we return the max score, which is 12. 
+
+**Example 2:**
+
+**Input:** nums1 = [4,2,3,1,1], nums2 = [7,5,10,9,6], k = 1
+
+**Output:** 30
+
+**Explanation:** Choosing index 2 is optimal: nums1[2] \* nums2[2] = 3 \* 10 = 30 is the maximum possible score. 
+
+**Constraints:**
+
+*   `n == nums1.length == nums2.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= nums1[i], nums2[j] <= 10<sup>5</sup></code>
+*   `1 <= k <= n`

src/test/java/g2501_2600/s2542_maximum_subsequence_score/SolutionTest.java

@@ -0,0 +1,22 @@
+package g2501_2600.s2542_maximum_subsequence_score;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxScore() {
+        assertThat(
+                new Solution().maxScore(new int[] {1, 3, 3, 2}, new int[] {2, 1, 3, 4}, 3),
+                equalTo(12L));
+    }
+
+    @Test
+    void maxScore2() {
+        assertThat(
+                new Solution().maxScore(new int[] {4, 2, 3, 1, 1}, new int[] {7, 5, 10, 9, 6}, 1),
+                equalTo(30L));
+    }
+}