sequence dp

Author: awangdev

Java/Best Time to Buy and Sell Stock I.java

@@ -1,5 +1,5 @@
 E
-1523511808
+1531717344
 tags: Array, DP, Sequence DP
 
 给个array of stock prices, 限制能交易(买/买)一轮, 问如何找到最大profit.
@@ -11,7 +11,8 @@
 
 #### DP
 - Find min value for first i items, new dp[n + 1].
-- 然后用当天的price做减法算max profit.
+- dp[i]: 前i天, prices最小的price是多少: min cost of first i days
+- 然后用当天的price做减法dp[i]算max profit.
 - Time, Space: O(n)
 - 更进一步, 用一个min来表示min[i], 因为计算中只需要当下的min.
 
@@ -27,7 +28,8 @@
 /*
 Say you have an array for which the ith element is the price of a given stock on day i.
 
-If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), 
+If you were only permitted to complete at most one transaction 
+(ie, buy one and sell one share of the stock), 
 design an algorithm to find the maximum profit.
 
 Example 1:
@@ -123,13 +125,12 @@ public int maxProfit(int[] prices) {
         if (prices == null || prices.length <= 1) {
             return 0;
         }
-        int profit = 0;
-        int min = prices[0];
+        int profit = 0, min = prices[0];
         for (int i = 1; i < prices.length; i++) {
-            if (prices[i] > min) {
-                profit = Math.max(profit, prices[i] - min);
-            } else {
+            if (prices[i] < min) {
                 min = prices[i];
+            } else {
+                profit = Math.max(profit, prices[i] - min);
             }
         }
         return profit;

Java/Best Time to Buy and Sell Stock II.java

@@ -1,6 +1,8 @@
 E
-1523511814
-tags: Array, Greedy, DP, Sequence DP
+1531717353
+tags: Array, Greedy, DP, Sequence DP, Status DP
+time: O(n)
+space: O(1) greedy, O(n) dp
 
 和Stock I 的区别：可以买卖多次，求总和的最大盈利.
 
@@ -11,7 +13,7 @@
 - DFS计算所有(timeout).Improvement on DFS -> DP -> calculate sellOn[i] and buyOn[i], and then return buyOn[i]. 有点难想, 但是代码简单, 也是O(n)
 
 #### Greedy
-- 画图, 因为可以无限买卖, 所以只要有上升, 就卖
+- 画图, 因为可以无限买卖, 所以只要有上升, 就有profit
 - 所有卖掉的, 平移加起来, 其实就是overall best profit
 - O(n)
 
@@ -21,13 +23,18 @@
 - profit += prices[peek - 1] - prices[start]; 挺特别的。
 - 当没有上涨趋势时候，peek-1也就是start, 所以这里刚好profit += 0.
 
-#### DP
-- 想知道前i天的最大profit, 那么用sequence DP
-- 当天的是否能卖, 取决于昨天是否买进, 也就是昨天买了或者卖了的状态: 加状态, 2D DP
-- 如果今天是卖的状态, 那么昨天: 要么买进了, 今天 +price 卖出; 要么昨天刚卖, 今天不可能再卖, profit等同.
-- 如果今天是买的状态, 那么昨天: 要么卖掉了, 今天 -price 买入; 要么昨天刚卖, 今天不可能再买, profit等同.
-
-#### Rolling Array
+#### DP, sequence dp + status
+- 想知道前i天的最大profit, 那么用sequence DP: 
+- dp[i]: represents 前i天的最大profit
+- 当天的是否能卖, 取决于昨天是否买进, 也就是 `昨天买了或者卖了的状态`: 加状态, dp[i][0], dp[i][1]
+- `买`的状态 `dp[i][0]` = 1. 今天买入, 昨天卖掉的dp[i-1][1]结果 - price[i]; 2. 今天不买, 跟昨天买的status dp[i-1][0] 结果 比较.
+- `卖`的状态 `dp[i][1]` = 1. 今天卖出, 昨天买进的dp[i-1][0]结果 + price[i]; 2. 今天不卖, 跟昨天卖的status dp[i-1][1] 结果 比较.
+- 注意init: 
+- dp[0][0] = dp[0][1] = 0; // 0 days, 
+- dp[1][0] = 0; // sell on 1st day, haven't bought, so just 0 profit.
+- dp[1][0] = -prices[0]; // buy on 1st day, with cost of prices[0]
+
+##### Rolling Array
 - [i] 和 [i - 1] 相关联, roll
 
 
@@ -53,6 +60,8 @@ at the same time (ie, you must sell the stock before you buy again).
 Draw a curve and realize that, only when prices[i] > prices[i - 1], 
 we complete buy/sell and take the profit.
 Adding more slopes can be greater than 0~N overall height diff. 
+
+// Greedy
 */
 class Solution {
     public int maxProfit(int[] prices) {
@@ -69,10 +78,7 @@ public int maxProfit(int[] prices) {
     }
 }
 
-/*
-DP
-Thoughts: See details at notes above
-*/
+//DP: See details at notes above
 class Solution {
     public int maxProfit(int[] prices) {
         if (prices == null || prices.length == 0) {
@@ -81,6 +87,7 @@ public int maxProfit(int[] prices) {
         int n = prices.length;
         int[][] dp = new int[n + 1][2];
         dp[0][0] = dp[0][1] = 0;
+        dp[1][1] = 0;
         dp[1][0] = - prices[0];// -2
         for (int i = 2; i <= n; i++) {
             dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i - 1]);

Java/Climbing Stairs.java

@@ -11,9 +11,10 @@
 - O(n) time, space
 
 #### DP
-- 最后一步被前两种走法决定: dp[i] = dp[i - 1] + dp[i - 2]
+- 加法原理, 最后一步被前两种走法决定: dp[i] = dp[i - 1] + dp[i - 2]
 - 基础sequence DP, int[] dp = int[n + 1];
 - DP[]存的是以 1-based index的状态
+- dp[i]: count # of ways to finish 前i个 台阶
 - 需要知道dp[n] 的状态, 但是最大坐标是[n-1], 所以int[n+1]
 - dp[0]往往是有特殊状态的
 - O(n) space, time

Java/Coin Change 2.java

@@ -1,6 +1,6 @@
 M
 1522735311
-tags: DP, Sequence DP, Backpack DP
+tags: DP, Backpack DP
 
 给串数字, target amount, 求总共多少种方式可以reach the amount.
 

Java/Coin Change.java

@@ -1,6 +1,6 @@
 M
 1516583739
-tags: DP, Sequence DP, Memoization
+tags: DP, Backpack DP, Memoization
 
 给一串不同数额的coins, 和total amount to spent. 求 最少 用多少个coin可以组合到这个amount. 每种coins个数不限量.
 

Java/House Robber II.java

@@ -1,10 +1,11 @@
 M
 1523329114
-tags: DP, Sequence DP
+tags: DP, Sequence DP, Status DP
 
 和House Robber I 类似, 搜刮房子, 相邻不能动. 特点是: 现在nums排成了圈, 首尾相连.
 
 #### Sequence DP
+- dp[i][status]: 在 status=[0,1] 情况下, 前i个 房子拿到的 max rob gain. status=0, 1st house robbed; status=1, 1st house skipped
 - 根据dp[i-1]是否被rob来讨论dp[i]: dp[i] = Math.max(dp[i-1], dp[i - 2] + nums[i - 1]);
 - 特别的是，末尾的last house 和 first house相连. 这里就需要分别讨论两种情况: 第一个房子被搜刮, 或者第一个房子没被搜刮
 - be careful with edge case nums = [0], only with 1 element.
@@ -55,13 +56,13 @@ public int rob(int[] nums) {
         dp[1][0] = 0; // not picking nums[0]
         dp[1][1] = nums[0]; // pick nums[0]
 
-        for (int i = 2; i < n; i++) { // spare the (i = n) case
+        for (int i = 2; i < n; i++) { // skip the (i = n) case
             dp[i][0] = Math.max(dp[i - 1][0], dp[i - 2][0] + nums[i - 1]);
             dp[i][1] = Math.max(dp[i - 1][1], dp[i - 2][1] + nums[i - 1]);
         }
         // i = n;
         dp[n][0] = Math.max(dp[n - 1][0], dp[n - 2][0] + nums[n - 1]);
-        dp[n][1] = dp[n - 1][1];
+        dp[n][1] = dp[n - 1][1]; // because the next-connected dp[0][1] was picked
 
         return (int) Math.max(dp[n][0], dp[n][1]);
     }

Java/House Robber.java

@@ -1,10 +1,13 @@
 E
 1523329104
 tags: DP, Sequence DP
+time: O(n)
+space: O(n) or rolling array O(1)
 
 搜刮房子, 相邻的不能碰. 每个房子里有value, 求max.
 
 #### Sequence DP
+- dp[i]: 前i个房子拿到的max gain
 - 看最后结尾状态的前一个或前两个的情况，再综合考虑当下的
 - 搞清楚当下[i]的和之前[i-x]的情况的关系: 不可以连着house, 那么就直接考虑 dp[i-2]的情况
 - Sequence DP, new dp[n + 1];

Java/Paint Fence.java

@@ -8,6 +8,7 @@
 - 最多2个fence 颜色相同
 - 假设i是和 i-1不同，那么结果就是 (k-1)*dp[i - 1]
 - 假设i是何 i-1相同，那么根据条件，i-1和i-2肯定不同。那么所有的结果就是(k-1)*dp[i-2]
+- dp[i]: count # of ways to paint 前i个 fence
 - 加法原理
 - time, space: O(n)
 - rolling array: space O(1)

Java/Paint House II.java

@@ -1,6 +1,8 @@
 H
 1523336609
-tags: DP, Sequence DP
+tags: DP, Sequence DP, Status DP
+time: O(NK^2):
+space: (NK)
 
 一排n个房子, 每个房子可涂成k种颜色, 涂每个房子的价钱不一样, 用costs[][]表示. 
 

Java/Paint House.java

@@ -1,6 +1,8 @@
 E
 1522770984
-tags: DP, Sequence DP
+tags: DP, Sequence DP, Status DP
+time: O(nm), m = # of colors
+space: O(nm)
 
 要paint n个房子, 还有 nx3的cost[][]. 求最少用多少cost paint 所有房子.
 

Java/Word Break.java

@@ -1,13 +1,15 @@
 M
-1527828369
+1531713769
 tags: DP, Sequence DP
+time: O(n^2)
+space: O(n)
 
 给一个String word, 和一个字典, 检查是否word可以被劈开, 而所有substring都应该是dictionary里面的words.
 
 #### Sequence DP
 - true/false problem, think about dp
 - 子问题: 前i个字母, 是否可以有valid break
-- 检查dp[j] && substring(j, i)
+- 检查dp[j] && substring(j, i), for all j = [0 ~ i]
 - dp = new boolean[n + 1]; dp[0] = true;
 - goal: if there is a j,  `dp[j] == true && word[j, n] in dict`. Need iterate over i = [0 ~ n], also j = [0, i]
 - 注意, 用set代替list, 因为要用 contains().
@@ -64,10 +66,8 @@
 class Solution {
     public boolean wordBreak(String s, List<String> dict) {
         // check edge case
-        if (s == null || s.length() == 0 
-            || dict == null || dict.size() == 0) {
-            return false;
-        }
+        if (s == null || s.length() == 0 || dict == null || dict.size() == 0) return false;
+
         Set<String> words = new HashSet<>(dict);
         // init dp
         int n = s.length();
@@ -78,9 +78,7 @@ public boolean wordBreak(String s, List<String> dict) {
         for (int i = 1; i <= n; i++) {
             for (int j = 0; j < i; j++) {
                 dp[i] |= dp[j] && words.contains(s.substring(j, i));
-                if (dp[i]) {
-                    break;
-                }
+                if (dp[i]) break;
             }
         }