feat: add No.1155,525

Author: BaffinLee

1101-1200/1155. Number of Dice Rolls With Target Sum.md

@@ -0,0 +1,88 @@
+# 1155. Number of Dice Rolls With Target Sum
+
+- Difficulty: Medium.
+- Related Topics: Dynamic Programming.
+- Similar Questions: Equal Sum Arrays With Minimum Number of Operations, Find Missing Observations.
+
+## Problem
+
+You have `n` dice, and each die has `k` faces numbered from `1` to `k`.
+
+Given three integers `n`, `k`, and `target`, return **the number of possible ways (out of the **`kn`** total ways) ****to roll the dice, so the sum of the face-up numbers equals **`target`. Since the answer may be too large, return it **modulo** `109 + 7`.
+
+ 
+Example 1:
+
+```
+Input: n = 1, k = 6, target = 3
+Output: 1
+Explanation: You throw one die with 6 faces.
+There is only one way to get a sum of 3.
+```
+
+Example 2:
+
+```
+Input: n = 2, k = 6, target = 7
+Output: 6
+Explanation: You throw two dice, each with 6 faces.
+There are 6 ways to get a sum of 7: 1+6, 2+5, 3+4, 4+3, 5+2, 6+1.
+```
+
+Example 3:
+
+```
+Input: n = 30, k = 30, target = 500
+Output: 222616187
+Explanation: The answer must be returned modulo 109 + 7.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= n, k <= 30`
+	
+- `1 <= target <= 1000`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @param {number} k
+ * @param {number} target
+ * @return {number}
+ */
+var numRollsToTarget = function(n, k, target) {
+    var dp = Array(n + 1).fill(0).map(() => ({}));
+    return helper(n, k, target, dp);
+};
+
+var helper = function(n, k, target, dp) {
+    if (dp[n][target] !== undefined) return dp[n][target];
+    if (n === 0 && target === 0) return 1;
+    if (n <= 0 || target <= 0) return 0;
+    var res = 0;
+    var mod = Math.pow(10, 9) + 7;
+    for (var i = 1; i <= k; i++) {
+        if (target < i) break;
+        res += helper(n - 1, k, target - i, dp);
+        res %= mod;
+    }
+    dp[n][target] = res;
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * target).
+* Space complexity : O(n * target).

501-600/525. Contiguous Array.md

@@ -0,0 +1,70 @@
+# 525. Contiguous Array
+
+- Difficulty: Medium.
+- Related Topics: Array, Hash Table, Prefix Sum.
+- Similar Questions: Maximum Size Subarray Sum Equals k.
+
+## Problem
+
+Given a binary array `nums`, return **the maximum length of a contiguous subarray with an equal number of **`0`** and **`1`.
+
+ 
+Example 1:
+
+```
+Input: nums = [0,1]
+Output: 2
+Explanation: [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
+```
+
+Example 2:
+
+```
+Input: nums = [0,1,0]
+Output: 2
+Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= nums.length <= 105`
+	
+- `nums[i]` is either `0` or `1`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMaxLength = function(nums) {
+    var map = {};
+    var count = 0;
+    var max = 0;
+    map[0] = -1;
+    for (var i = 0; i < nums.length; i++) {
+        count += (nums[i] === 1 ? 1 : -1);
+        if (map[count] !== undefined) {
+            max = Math.max(max, i - map[count])
+        } else {
+            map[count] = i;
+        }
+    }
+    return max;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).