solves #2389: Longest Subsequence With Limited Sum in java

Author: anishLearnsToCode

README.md

@@ -762,7 +762,7 @@
 | 2373 | [Largest Local Values in a Matrix](https://leetcode.com/problems/largest-local-values-in-a-matrix)                                                                     |                                                                                 [![Java](assets/java.png)](src/LargestLocalValuesInAMatrix.java)                                                                                 |                                                                                                                                   |
 | 2379 | [Minimum Recolors to Get K Consecutive Black Blocks](https://leetcode.com/problems/minimum-recolors-to-get-k-consecutive-black-blocks)                                 |                                                                         [![Java](assets/java.png)](src/MinimumRecolorsToGetKConsecutiveBlackBlocks.java)                                                                         |                                                                                                                                   |
 | 2383 | [Minimum Hours of Training to Win a Competition](https://leetcode.com/problems/minimum-hours-of-training-to-win-a-competition)                                         |                                                                           [![Java](assets/java.png)](src/MinimumHoursOfTrainingToWinACompetition.java)                                                                           |                                                                                                                                   |
-| 2389 | [Longest Subsequence With Limited Sum](https://leetcode.com/problems/longest-subsequence-with-limited-sum)                                                             |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 2389 | [Longest Subsequence With Limited Sum](https://leetcode.com/problems/longest-subsequence-with-limited-sum)                                                             |                                                                              [![Java](assets/java.png)](src/LongestSubsequenceWithLimitedSum.java)                                                                               |                                                                                                                                   |
 | 2395 | [Find Subarrays With Equal Sum](https://leetcode.com/problems/find-subarrays-with-equal-sum)                                                                           |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 2399 | [Check Distances Between Same Letters](https://leetcode.com/problems/check-distances-between-same-letters)                                                             |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 2404 | [Most Frequent Even Element](https://leetcode.com/problems/most-frequent-even-element)                                                                                 |                                                                                                                                                                                                                                  |                                                                                                                                   |

src/HelloWorld.java

@@ -1,35 +1,13 @@
+import java.util.PriorityQueue;
+import java.util.Queue;
+
 public class HelloWorld {
     public static void main(String[] args) {
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {1, 2, 3})
-        );
-
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9})
-        );
-
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {10, 2})
-        );
-
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {1})
-        );
-
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {1, 10, 11, 12})
-        );
-
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {1, 10, 11, 12, 16, 15, 14, 13, 19, 18, 17})
-        );
-
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {3, 30, 34, 5, 9})
-        );
+        final Queue<Integer> queue = new PriorityQueue<>();
+        queue.add(10);
+        queue.add(4);
+        queue.add(-2);
 
-        System.out.println(
-                LargestNumber.largestNumber(new int[] {432, 43243})
-        );
+        System.out.println(queue.peek());
     }
 }

src/LongestSubsequenceWithLimitedSum.java

@@ -0,0 +1,46 @@
+// https://leetcode.com/problems/longest-subsequence-with-limited-sum
+// T: O((n + m) log(n))
+// S: O(n)
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class LongestSubsequenceWithLimitedSum {
+    public int[] answerQueries(int[] nums, int[] queries) {
+        final int[] result = new int[queries.length];
+        final int[] prefixSumArray = getMinSumArray(nums);
+
+        for (int index = 0 ; index < queries.length ; index++) {
+            int maxLen = binarySearch(prefixSumArray, queries[index]);
+            if (maxLen < prefixSumArray.length && prefixSumArray[maxLen] == queries[index]) {
+                result[index] = maxLen + 1;
+            } else result[index] = maxLen;
+        }
+
+        return result;
+    }
+
+    private int binarySearch(int[] array, int x) {
+        int left = 0, right = array.length - 1, index = 0;
+        while (left <= right) {
+            index = left + (right - left) / 2;
+            if (array[index] == x) return index;
+            else if (array[index] > x) right = index - 1;
+            else left = index + 1;
+        }
+        return left;
+    }
+
+    private int[] getMinSumArray(int[] array) {
+        final Queue<Integer> minHeap = new PriorityQueue<>();
+        final int[] result = new int[array.length];
+        for (int element : array) {
+            minHeap.add(element);
+        }
+        result[0] = minHeap.poll();
+        for (int index = 1 ; index < result.length ; index++) {
+            result[index] = result[index - 1] + minHeap.poll();
+        }
+        return result;
+    }
+}