feat: solve No.714,2742

Author: BaffinLee

2701-2800/2742. Painting the Walls.md

@@ -0,0 +1,83 @@
+# 2742. Painting the Walls
+
+- Difficulty: Hard.
+- Related Topics: Array, Dynamic Programming.
+- Similar Questions: .
+
+## Problem
+
+You are given two **0-indexed** integer arrays, `cost` and `time`, of size `n` representing the costs and the time taken to paint `n` different walls respectively. There are two painters available:
+
+
+	
+- A** paid painter** that paints the `ith` wall in `time[i]` units of time and takes `cost[i]` units of money.
+	
+- A** free painter** that paints **any** wall in `1` unit of time at a cost of `0`. But the free painter can only be used if the paid painter is already **occupied**.
+
+
+Return **the minimum amount of money required to paint the **`n`** walls.**
+
+ 
+Example 1:
+
+```
+Input: cost = [1,2,3,2], time = [1,2,3,2]
+Output: 3
+Explanation: The walls at index 0 and 1 will be painted by the paid painter, and it will take 3 units of time; meanwhile, the free painter will paint the walls at index 2 and 3, free of cost in 2 units of time. Thus, the total cost is 1 + 2 = 3.
+```
+
+Example 2:
+
+```
+Input: cost = [2,3,4,2], time = [1,1,1,1]
+Output: 4
+Explanation: The walls at index 0 and 3 will be painted by the paid painter, and it will take 2 units of time; meanwhile, the free painter will paint the walls at index 1 and 2, free of cost in 2 units of time. Thus, the total cost is 2 + 2 = 4.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= cost.length <= 500`
+	
+- `cost.length == time.length`
+	
+- `1 <= cost[i] <= 106`
+	
+- `1 <= time[i] <= 500`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} cost
+ * @param {number[]} time
+ * @return {number}
+ */
+var paintWalls = function(cost, time) {
+    var dp = Array(cost.length).fill(0).map(() => Array(cost.length + 1));
+    return helper(cost, time, 0, cost.length, dp);
+};
+
+var helper = function(cost, time, i, remains, dp) {
+    if (remains <= 0) return 0;
+    if (i === cost.length) return Number.MAX_SAFE_INTEGER;
+    if (dp[i][remains] !== undefined) return dp[i][remains];
+    var paintByPaidPainter = cost[i] + helper(cost, time, i + 1, remains - time[i] - 1, dp);
+    var paintByFreePainter = helper(cost, time, i + 1, remains, dp);
+    dp[i][remains] = Math.min(paintByPaidPainter, paintByFreePainter);
+    return dp[i][remains];
+};
+```
+
+**Explain:**
+
+Top down dp.
+
+**Complexity:**
+
+* Time complexity : O(n ^ 2).
+* Space complexity : O(n ^ 2).

701-800/714. Best Time to Buy and Sell Stock with Transaction Fee.md

@@ -0,0 +1,84 @@
+# 714. Best Time to Buy and Sell Stock with Transaction Fee
+
+- Difficulty: Medium.
+- Related Topics: Array, Dynamic Programming, Greedy.
+- Similar Questions: Best Time to Buy and Sell Stock II.
+
+## Problem
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day, and an integer `fee` representing a transaction fee.
+
+Find the maximum profit you can achieve. You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction.
+
+**Note:**
+
+
+	
+- You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+	
+- The transaction fee is only charged once for each stock purchase and sale.
+
+
+ 
+Example 1:
+
+```
+Input: prices = [1,3,2,8,4,9], fee = 2
+Output: 8
+Explanation: The maximum profit can be achieved by:
+- Buying at prices[0] = 1
+- Selling at prices[3] = 8
+- Buying at prices[4] = 4
+- Selling at prices[5] = 9
+The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
+```
+
+Example 2:
+
+```
+Input: prices = [1,3,7,5,10,3], fee = 3
+Output: 6
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= prices.length <= 5 * 104`
+	
+- `1 <= prices[i] < 5 * 104`
+	
+- `0 <= fee < 5 * 104`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} prices
+ * @param {number} fee
+ * @return {number}
+ */
+var maxProfit = function(prices, fee) {
+    var hasStock = Number.MIN_SAFE_INTEGER;
+    var hasNoStock = 0;
+    for (var i = 0; i < prices.length; i++) {
+        var a = Math.max(hasStock, hasNoStock - prices[i]);
+        var b = Math.max(hasNoStock, hasStock + prices[i] - fee);
+        hasStock = a;
+        hasNoStock = b;
+    }
+    return Math.max(hasStock, hasNoStock);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).