feat: solve No.1475,2770

Author: BaffinLee

1401-1500/1475. Final Prices With a Special Discount in a Shop.md

@@ -0,0 +1,82 @@
+# 1475. Final Prices With a Special Discount in a Shop
+
+- Difficulty: Easy.
+- Related Topics: Array, Stack, Monotonic Stack.
+- Similar Questions: .
+
+## Problem
+
+You are given an integer array `prices` where `prices[i]` is the price of the `ith` item in a shop.
+
+There is a special discount for items in the shop. If you buy the `ith` item, then you will receive a discount equivalent to `prices[j]` where `j` is the minimum index such that `j > i` and `prices[j] <= prices[i]`. Otherwise, you will not receive any discount at all.
+
+Return an integer array `answer` where `answer[i]` is the final price you will pay for the `ith` item of the shop, considering the special discount.
+
+ 
+Example 1:
+
+```
+Input: prices = [8,4,6,2,3]
+Output: [4,2,4,2,3]
+Explanation: 
+For item 0 with price[0]=8 you will receive a discount equivalent to prices[1]=4, therefore, the final price you will pay is 8 - 4 = 4.
+For item 1 with price[1]=4 you will receive a discount equivalent to prices[3]=2, therefore, the final price you will pay is 4 - 2 = 2.
+For item 2 with price[2]=6 you will receive a discount equivalent to prices[3]=2, therefore, the final price you will pay is 6 - 2 = 4.
+For items 3 and 4 you will not receive any discount at all.
+```
+
+Example 2:
+
+```
+Input: prices = [1,2,3,4,5]
+Output: [1,2,3,4,5]
+Explanation: In this case, for all items, you will not receive any discount at all.
+```
+
+Example 3:
+
+```
+Input: prices = [10,1,1,6]
+Output: [9,0,1,6]
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= prices.length <= 500`
+	
+- `1 <= prices[i] <= 1000`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} prices
+ * @return {number[]}
+ */
+var finalPrices = function(prices) {
+    var res = Array.from(prices);
+    for (var i = 0; i < prices.length; i++) {
+        for (var j = i + 1; j < prices.length; j++) {
+            if (prices[j] <= prices[i]) {
+                res[i] = prices[i] - prices[j];
+                break;
+            }
+        }
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n ^ 2).
+* Space complexity : O(n).

2701-2800/2770. Maximum Number of Jumps to Reach the Last Index.md

@@ -0,0 +1,101 @@
+# 2770. Maximum Number of Jumps to Reach the Last Index
+
+- Difficulty: Medium.
+- Related Topics: Array, Dynamic Programming.
+- Similar Questions: Jump Game II, Frog Jump, Jump Game III, Jump Game IV, Minimum Jumps to Reach Home, Jump Game VII.
+
+## Problem
+
+You are given a **0-indexed** array `nums` of `n` integers and an integer `target`.
+
+You are initially positioned at index `0`. In one step, you can jump from index `i` to any index `j` such that:
+
+
+	
+- `0 <= i < j < n`
+	
+- `-target <= nums[j] - nums[i] <= target`
+
+
+Return **the **maximum number of jumps** you can make to reach index** `n - 1`.
+
+If there is no way to reach index `n - 1`, return `-1`.
+
+ 
+Example 1:
+
+```
+Input: nums = [1,3,6,4,1,2], target = 2
+Output: 3
+Explanation: To go from index 0 to index n - 1 with the maximum number of jumps, you can perform the following jumping sequence:
+- Jump from index 0 to index 1. 
+- Jump from index 1 to index 3.
+- Jump from index 3 to index 5.
+It can be proven that there is no other jumping sequence that goes from 0 to n - 1 with more than 3 jumps. Hence, the answer is 3. 
+```
+
+Example 2:
+
+```
+Input: nums = [1,3,6,4,1,2], target = 3
+Output: 5
+Explanation: To go from index 0 to index n - 1 with the maximum number of jumps, you can perform the following jumping sequence:
+- Jump from index 0 to index 1.
+- Jump from index 1 to index 2.
+- Jump from index 2 to index 3.
+- Jump from index 3 to index 4.
+- Jump from index 4 to index 5.
+It can be proven that there is no other jumping sequence that goes from 0 to n - 1 with more than 5 jumps. Hence, the answer is 5. 
+```
+
+Example 3:
+
+```
+Input: nums = [1,3,6,4,1,2], target = 0
+Output: -1
+Explanation: It can be proven that there is no jumping sequence that goes from 0 to n - 1. Hence, the answer is -1. 
+```
+
+ 
+**Constraints:**
+
+
+	
+- `2 <= nums.length == n <= 1000`
+	
+- `-109 <= nums[i] <= 109`
+	
+- `0 <= target <= 2 * 109`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var maximumJumps = function(nums, target) {
+    var dp = Array(nums.length);
+    for (var i = nums.length - 1; i >= 0; i--) {
+        dp[i] = i === nums.length - 1 ? 0 : -1;
+        for (var j = i + 1; j < nums.length; j++) {
+            if (Math.abs(nums[j] - nums[i]) <= target && dp[j] !== -1) {
+                dp[i] = Math.max(dp[i], 1 + dp[j]);
+            }
+        }
+    }
+    return dp[0];
+};
+```
+
+**Explain:**
+
+Bottom-up dynamic programming.
+
+**Complexity:**
+
+* Time complexity : O(n ^ 2).
+* Space complexity : O(n).