Added task 2386.

Author: javadev

README.md

@@ -1848,6 +1848,7 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2386 |[Find the K-Sum of an Array](src/main/java/g2301_2400/s2386_find_the_k_sum_of_an_array/Solution.java)| Hard | Array, Sorting, Heap_(Priority_Queue) | 75 | 100.00
 | 2385 |[Amount of Time for Binary Tree to Be Infected](src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/Solution.java)| Medium | Tree, Binary_Tree, Depth_First_Search, Breadth_First_Search | 20 | 100.00
 | 2384 |[Largest Palindromic Number](src/main/java/g2301_2400/s2384_largest_palindromic_number/Solution.java)| Medium | String, Hash_Table, Greedy | 26 | 100.00
 | 2383 |[Minimum Hours of Training to Win a Competition](src/main/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/Solution.java)| Easy | Array, Greedy | 0 | 100.00

src/main/java/g2301_2400/s2386_find_the_k_sum_of_an_array/Solution.java

@@ -0,0 +1,56 @@
+package g2301_2400.s2386_find_the_k_sum_of_an_array;
+
+// #Hard #Array #Sorting #Heap_(Priority_Queue)
+// #2022_08_25_Time_75_ms_(100.00%)_Space_86.8_MB_(33.33%)
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public long kSum(int[] nums, int k) {
+        long sum = 0L;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] > 0) {
+                sum += nums[i];
+            } else {
+                nums[i] = -nums[i];
+            }
+        }
+        Arrays.sort(nums);
+        PriorityQueue<Pair<Long, Integer>> pq =
+                new PriorityQueue<>((a, b) -> Long.compare(b.getKey(), a.getKey()));
+        pq.offer(new Pair<>(sum, 0));
+        while (k-- > 1) {
+            Pair<Long, Integer> top = pq.poll();
+            if (top != null) {
+                long s = top.getKey();
+                int i = top.getValue();
+                if (i < nums.length) {
+                    pq.offer(new Pair<>(s - nums[i], i + 1));
+                    if (i > 0) {
+                        pq.offer(new Pair<>(s - nums[i] + nums[i - 1], i + 1));
+                    }
+                }
+            }
+        }
+        return pq.peek().getKey();
+    }
+
+    private static class Pair<K, V> {
+        K key;
+        V value;
+
+        public Pair(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+2386\. Find the K-Sum of an Array
+
+Hard
+
+You are given an integer array `nums` and a **positive** integer `k`. You can choose any **subsequence** of the array and sum all of its elements together.
+
+We define the **K-Sum** of the array as the <code>k<sup>th</sup></code> **largest** subsequence sum that can be obtained (**not** necessarily distinct).
+
+Return _the K-Sum of the array_.
+
+A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+
+**Note** that the empty subsequence is considered to have a sum of `0`.
+
+**Example 1:**
+
+**Input:** nums = [2,4,-2], k = 5
+
+**Output:** 2
+
+**Explanation:** All the possible subsequence sums that we can obtain are the following sorted in decreasing order:
+
+- 6, 4, 4, 2, <ins>2</ins>, 0, 0, -2.
+
+The 5-Sum of the array is 2. 
+
+**Example 2:**
+
+**Input:** nums = [1,-2,3,4,-10,12], k = 16
+
+**Output:** 10
+
+**Explanation:** The 16-Sum of the array is 10. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= k <= min(2000, 2<sup>n</sup>)</code>

src/test/java/g2301_2400/s2386_find_the_k_sum_of_an_array/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2386_find_the_k_sum_of_an_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void kSum() {
+        assertThat(new Solution().kSum(new int[] {2, 4, -2}, 5), equalTo(2L));
+    }
+
+    @Test
+    void kSum2() {
+        assertThat(new Solution().kSum(new int[] {1, -2, 3, 4, -10, 12}, 16), equalTo(10L));
+    }
+}