feat: solve No.1508,2053

Author: BaffinLee

1501-1600/1508. Range Sum of Sorted Subarray Sums.md

@@ -0,0 +1,90 @@
+# 1508. Range Sum of Sorted Subarray Sums
+
+- Difficulty: Medium.
+- Related Topics: Array, Two Pointers, Binary Search, Sorting.
+- Similar Questions: .
+
+## Problem
+
+You are given the array `nums` consisting of `n` positive integers. You computed the sum of all non-empty continuous subarrays from the array and then sorted them in non-decreasing order, creating a new array of `n * (n + 1) / 2` numbers.
+
+**Return the sum of the numbers from index **`left`** to index **`right` (**indexed from 1**)**, inclusive, in the new array. **Since the answer can be a huge number return it modulo `109 + 7`.
+
+ 
+Example 1:
+
+```
+Input: nums = [1,2,3,4], n = 4, left = 1, right = 5
+Output: 13 
+Explanation: All subarray sums are 1, 3, 6, 10, 2, 5, 9, 3, 7, 4. After sorting them in non-decreasing order we have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 1 to ri = 5 is 1 + 2 + 3 + 3 + 4 = 13. 
+```
+
+Example 2:
+
+```
+Input: nums = [1,2,3,4], n = 4, left = 3, right = 4
+Output: 6
+Explanation: The given array is the same as example 1. We have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 3 to ri = 4 is 3 + 3 = 6.
+```
+
+Example 3:
+
+```
+Input: nums = [1,2,3,4], n = 4, left = 1, right = 10
+Output: 50
+```
+
+ 
+**Constraints:**
+
+
+	
+- `n == nums.length`
+	
+- `1 <= nums.length <= 1000`
+	
+- `1 <= nums[i] <= 100`
+	
+- `1 <= left <= right <= n * (n + 1) / 2`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} n
+ * @param {number} left
+ * @param {number} right
+ * @return {number}
+ */
+var rangeSum = function(nums, n, left, right) {
+    var queue = new MinPriorityQueue();
+    for (var i = 0; i < nums.length; i++) {
+        queue.enqueue(i, nums[i]);
+    }
+    var res = 0;
+    var mod = Math.pow(10, 9) + 7;
+    for (var j = 0; j < right; j++) {
+        var { element, priority } = queue.dequeue();
+        if (element < nums.length - 1) {
+            queue.enqueue(element + 1, priority + nums[element + 1]);
+        }
+        if (j >= left - 1) {
+            res += priority;
+            res %= mod;
+        }
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n^2 * log(n)).
+* Space complexity : O(n).

2001-2100/2053. Kth Distinct String in an Array.md

@@ -0,0 +1,89 @@
+# 2053. Kth Distinct String in an Array
+
+- Difficulty: Easy.
+- Related Topics: Array, Hash Table, String, Counting.
+- Similar Questions: Count Common Words With One Occurrence.
+
+## Problem
+
+A **distinct string** is a string that is present only **once** in an array.
+
+Given an array of strings `arr`, and an integer `k`, return **the **`kth`** **distinct string** present in **`arr`. If there are **fewer** than `k` distinct strings, return **an **empty string ****`""`.
+
+Note that the strings are considered in the **order in which they appear** in the array.
+
+ 
+Example 1:
+
+```
+Input: arr = ["d","b","c","b","c","a"], k = 2
+Output: "a"
+Explanation:
+The only distinct strings in arr are "d" and "a".
+"d" appears 1st, so it is the 1st distinct string.
+"a" appears 2nd, so it is the 2nd distinct string.
+Since k == 2, "a" is returned. 
+```
+
+Example 2:
+
+```
+Input: arr = ["aaa","aa","a"], k = 1
+Output: "aaa"
+Explanation:
+All strings in arr are distinct, so the 1st string "aaa" is returned.
+```
+
+Example 3:
+
+```
+Input: arr = ["a","b","a"], k = 3
+Output: ""
+Explanation:
+The only distinct string is "b". Since there are fewer than 3 distinct strings, we return an empty string "".
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= k <= arr.length <= 1000`
+	
+- `1 <= arr[i].length <= 5`
+	
+- `arr[i]` consists of lowercase English letters.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string[]} arr
+ * @param {number} k
+ * @return {string}
+ */
+var kthDistinct = function(arr, k) {
+    var map = {};
+    for (var i = 0; i < arr.length; i++) {
+        map[arr[i]] = (map[arr[i]] || 0) + 1;
+    }
+    for (var j = 0; j < arr.length; j++) {
+        if (map[arr[j]] === 1) {
+            k--;
+            if (k === 0) return arr[j];
+        }
+    }
+    return '';
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).