feat: solve No.1269,2400

Author: BaffinLee

1201-1300/1269. Number of Ways to Stay in the Same Place After Some Steps.md

@@ -0,0 +1,87 @@
+# 1269. Number of Ways to Stay in the Same Place After Some Steps
+
+- Difficulty: Hard.
+- Related Topics: Dynamic Programming.
+- Similar Questions: Number of Ways to Reach a Position After Exactly k Steps.
+
+## Problem
+
+You have a pointer at index `0` in an array of size `arrLen`. At each step, you can move 1 position to the left, 1 position to the right in the array, or stay in the same place (The pointer should not be placed outside the array at any time).
+
+Given two integers `steps` and `arrLen`, return the number of ways such that your pointer is still at index `0` after **exactly** `steps` steps. Since the answer may be too large, return it **modulo** `109 + 7`.
+
+ 
+Example 1:
+
+```
+Input: steps = 3, arrLen = 2
+Output: 4
+Explanation: There are 4 differents ways to stay at index 0 after 3 steps.
+Right, Left, Stay
+Stay, Right, Left
+Right, Stay, Left
+Stay, Stay, Stay
+```
+
+Example 2:
+
+```
+Input: steps = 2, arrLen = 4
+Output: 2
+Explanation: There are 2 differents ways to stay at index 0 after 2 steps
+Right, Left
+Stay, Stay
+```
+
+Example 3:
+
+```
+Input: steps = 4, arrLen = 2
+Output: 8
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= steps <= 500`
+	
+- `1 <= arrLen <= 106`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} steps
+ * @param {number} arrLen
+ * @return {number}
+ */
+var numWays = function(steps, arrLen) {
+    if (arrLen === 1) return 1;
+    arrLen = Math.min(arrLen, steps);
+    var mod = Math.pow(10, 9) + 7;
+    var lastArr = Array(arrLen).fill(0);
+    lastArr[0] = 1;
+    lastArr[1] = 1;
+    for (var i = 1; i < steps; i++) {
+        var newArr = Array(arrLen);
+        for (var j = 0; j < arrLen; j++) {
+            newArr[j] = (lastArr[j] + (lastArr[j - 1] || 0) + (lastArr[j + 1] || 0)) % mod;
+        }
+        lastArr = newArr;
+    }
+    return lastArr[0];
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * min(n * m)).
+* Space complexity : O(n).

2301-2400/2400. Number of Ways to Reach a Position After Exactly k Steps.md

@@ -0,0 +1,78 @@
+# 2400. Number of Ways to Reach a Position After Exactly k Steps
+
+- Difficulty: Medium.
+- Related Topics: Math, Dynamic Programming, Combinatorics.
+- Similar Questions: Unique Paths, Climbing Stairs, Reach a Number, Reaching Points, Number of Ways to Stay in the Same Place After Some Steps.
+
+## Problem
+
+You are given two **positive** integers `startPos` and `endPos`. Initially, you are standing at position `startPos` on an **infinite** number line. With one step, you can move either one position to the left, or one position to the right.
+
+Given a positive integer `k`, return **the number of **different** ways to reach the position **`endPos`** starting from **`startPos`**, such that you perform **exactly** **`k`** steps**. Since the answer may be very large, return it **modulo** `109 + 7`.
+
+Two ways are considered different if the order of the steps made is not exactly the same.
+
+**Note** that the number line includes negative integers.
+
+ 
+Example 1:
+
+```
+Input: startPos = 1, endPos = 2, k = 3
+Output: 3
+Explanation: We can reach position 2 from 1 in exactly 3 steps in three ways:
+- 1 -> 2 -> 3 -> 2.
+- 1 -> 2 -> 1 -> 2.
+- 1 -> 0 -> 1 -> 2.
+It can be proven that no other way is possible, so we return 3.
+```
+
+Example 2:
+
+```
+Input: startPos = 2, endPos = 5, k = 10
+Output: 0
+Explanation: It is impossible to reach position 5 from position 2 in exactly 10 steps.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= startPos, endPos, k <= 1000`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} startPos
+ * @param {number} endPos
+ * @param {number} k
+ * @return {number}
+ */
+var numberOfWays = function(startPos, endPos, k, dp = {}) {
+    if (startPos === endPos && k === 0) return 1;
+    if (k === 0) return 0;
+    if (Math.abs(startPos - endPos) > k) return 0;
+    if (!dp[startPos]) dp[startPos] = {};
+    if (dp[startPos][k] === undefined) {
+        dp[startPos][k] = (
+            numberOfWays(startPos + 1, endPos, k - 1, dp) +
+            numberOfWays(startPos - 1, endPos, k - 1, dp)
+        ) % (Math.pow(10, 9) + 7);
+    }
+    return dp[startPos][k];
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(k ^ 2).
+* Space complexity : O(k ^ 2).