review stock trading series

Author: RUAN0007

Basic.md

@@ -198,13 +198,66 @@ In [1,3,0,2,4] or [1,3,5,0,2,4], every consecutive 3 are not adjacent.
 * [1424. Diagonal Traverse II](src/problem/p1424_diagonal_traverse_ii.rs)
 
 ## Bit Operation
-## 2 Pointer
+### Basics
+* [190. Reverse Bits](src/problem/p0190_reverse_bits.rs) (Repeatedly test and set)
+* [191. Number of 1 Bits](src/problem/p0191_number_of_1_bits.rs) (Use x&=x-1 to repeatively unset the least significant 1-bit. )
+* [693. Binary Number with Alternating Bits](src/problem/p0693_binary_number_with_alternating_bits.rs) (Use x&(x+1)==0 to check whether x=(2^n-1))
+* [137. Single Number II](src/problem/p0260_single_number_ii.rs) (Find the single unique elements that appear k times, while the rest with n times. )
+  * Implement a cyclic counter with period n for each bit when xoring elements
+  * Return i-th bit counter if the i-th bit is set in binary k. 
+* [260. Single Number III](src/problem/p0260_single_number_iii.rs) (Find the two unique elements, (x,y) that appear k (k is odd) times, while the rest with n times. )
+  * Implement a cyclic counter with period n for each bit when xoring elements
+  * Locate any i-th bit counter, which is none-zero.(x,y differs in i-th bit).
+  * Separate all elements into two groups by i-th bit and redo p137 to discovery x and y. 
+* [29. Divide Two Integers](src/problem/p0029_divide_two_integers.rs)
+* [371. Sum of Two Integers](src/problem/p0371_sum_of_two_integers.rs)
+* [201. Bitwise AND of Numbers Range](src/problem/p0201_bitwise_and_of_numbers_range.rs)
+
+
+## Two-Pointer
 ## Array/String
 ## DP
+## Series
+### Palindrome
+```
+NOTE: DP recursion for palindrome
+is_palindrome(i,j) |= is_palindrome(k,j-1) && s[k-1] == s[j] for any k
+```
+
+* [5. Longest Palindromic Substring](src/problem/p0005_longest_palindromic_substring.rs)
+### Stocks Trading
+Key recursion: 
+```
+// no_stock_balances[i][k] represents the max balance at the end of i-th day with at most k txns, conditioned on no stock hold
+// with_stock_balances[i][k] represents the max balance at the end of i-th day with at most k txns, conditioned on stocks holded
+no_stock_balances[i<=0][*]=0; // initial condition
+no_stock_balances[*][k=0]=0; // initial condition
+with_stock_balances[*][k=0]=MIN; // imply N.A. to work with the below max operation
+
+// sell
+no_stock_balances[i][k] = max(no_stock_balances[i-1][k], with_stock_balances[i-1][k] + prices[i])
+// buy
+with_stock_balances[i][k] = max(with_stock_balances[i-1][k], no_stock_balances[i-1][k-1] - prices[i])
+```
+
+* [121. Best Time to Buy and Sell Stock](src/problem/p0121_best_time_to_buy_and_sell_stock.rs) (k=1)
+  * Enumerate k dimension with named variables.
+  * Always replace no_stock_balances[i-1][k-1] with 0 as k=1
+* [122. Best Time to Buy and Sell Stock II](src/problem/p0122_best_time_to_buy_and_sell_stock_ii.rs) (k=inf)
+  * Due inf, no_stock_balances[\*][k]=no_stock_balances[\*][k-1], and similar to with_stock_balances. Hence, the dimension for k can be removed. 
+* [188. Best Time to Buy and Sell Stock IV](src/problem/p0188_best_time_to_buy_and_sell_stock_iv.rs) (Arbitrary k)
+  * Minor Optimization: since a txn must span at least two days, one day to buy and one day to sell, when k >n/2, it is equivalent to k = inf. 
+* [714. Best Time to Buy and Sell Stock with Transaction Fee](src/problem/p0714_best_time_to_buy_and_sell_stock_with_transaction_fee.rs)
+  * Similar to [P122](src/problem/p0122_best_time_to_buy_and_sell_stock_ii.rs).
+  * Can pay the fee either during the buy or the sell. 
+* [309. Best Time to Buy and Sell Stock with Cooldown](src/problem/p0309_best_time_to_buy_and_sell_stock_with_cooldown.rs) (cool down with inf k)
+  * with_stock_balances[i][k] = max(with_stock_balances[i-1][k], no_stock_balances[**i-2**][k-1] - prices[i])
+
+
 ## Others
+* [229. Majority Element II](src/problem/p0229_majority_element_ii.rs)
+  * (B-M Majority Vote)
 * [42. Trapping Rain Water](src/problem/p0042_trapping_rain_water.rs)
-### Palindrome Series
-NOTE: DP recursion for palindrome
 # [Collected Template](src/problem/p0000_template.rs)
 * Data structure:
     * BtreeMap

src/problem/mod.rs

@@ -172,3 +172,10 @@ mod p0212_word_search_ii;
 mod p0875_koko_eating_bananas;
 mod p0498_diagonal_traverse;
 mod p1424_diagonal_traverse_ii;
+mod p0191_number_of_1_bits;
+mod p0005_longest_palindromic_substring;
+mod p0214_shortest_palindrome;
+mod p0188_best_time_to_buy_and_sell_stock_iv;
+mod p0123_best_time_to_buy_and_sell_stock_iii;
+mod p0122_best_time_to_buy_and_sell_stock_ii;
+mod p0714_best_time_to_buy_and_sell_stock_with_transaction_fee;

src/problem/p0121_best_time_to_buy_and_sell_stock.rs

@@ -34,6 +34,17 @@ pub struct Solution {}
 
 impl Solution {
     pub fn max_profit(prices: Vec<i32>) -> i32 {
+        let mut last_no_stock_balance = 0i32;
+        let mut last_with_stock_balance = -2_147_483_648i32;
+        for &price in prices.iter() {
+            last_no_stock_balance = std::cmp::max(last_no_stock_balance, last_with_stock_balance + price);
+
+            last_with_stock_balance = std::cmp::max(last_with_stock_balance, 0 - price);
+        }
+        last_no_stock_balance
+    }
+
+    pub fn max_profit1(prices: Vec<i32>) -> i32 {
         // kadane's alg on consecutive diff. 
         let mut max_so_far = 0;
         let mut cur_max = 0;

src/problem/p0122_best_time_to_buy_and_sell_stock_ii.rs

@@ -0,0 +1,122 @@
+/**
+ * [122] Best Time to Buy and Sell Stock II
+ *
+ * You are given an array prices where prices[i] is the price of a given stock on the i^th day.
+ * Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).
+ * Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+ *  
+ * Example 1:
+ * 
+ * Input: prices = [7,1,5,3,6,4]
+ * Output: 7
+ * Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+ * Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+ * 
+ * Example 2:
+ * 
+ * Input: prices = [1,2,3,4,5]
+ * Output: 4
+ * Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+ * Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+ * 
+ * Example 3:
+ * 
+ * Input: prices = [7,6,4,3,1]
+ * Output: 0
+ * Explanation: In this case, no transaction is done, i.e., max profit = 0.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= prices.length <= 3 * 10^4
+ * 	0 <= prices[i] <= 10^4
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/
+// discuss: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>) -> i32 {
+        let mut last_no_stock_balance : i32 = 0;
+        let mut last_with_stock_balance : i32 = -2_147_483_648i32;
+
+        for price in prices.iter() {
+            let last_no_stock_balance_cache = last_no_stock_balance;
+            last_no_stock_balance = std::cmp::max(last_no_stock_balance, last_with_stock_balance + price);
+
+            last_with_stock_balance = std::cmp::max(last_with_stock_balance, last_no_stock_balance_cache - price)
+        }
+        last_no_stock_balance
+    }
+
+    pub fn max_profit1(prices: Vec<i32>) -> i32 {
+        let n : usize = prices.len();
+        if n == 0 || n == 1 {return 0;}
+        let mut local_mins : Vec<i32> = vec![];
+        let mut local_maxs : Vec<i32> = vec![];
+
+        let is_local_min = |i|{ 
+            if i==0 {
+                prices[i] <= prices[i+1]
+            } else if i == n-1 {
+                false
+            } else {
+                prices[i-1] >= prices[i] && prices[i] <= prices[i+1]
+            }
+        };
+
+        let is_local_max = |i|{ 
+            if i==0 {
+                false
+            } else if i == n-1 {
+                prices[i-1] <= prices[i]
+            } else {
+                prices[i-1] <= prices[i] && prices[i] >= prices[i+1]
+            }
+        };
+        let mut i : usize = 0;
+        loop {
+            let mut cur_local_min : i32 = 0;
+            let mut cur_local_max : i32 = 0;
+            while i < n && !is_local_min(i) {
+                i+=1;
+            }
+            if i == n { break;}
+            cur_local_min = prices[i];
+
+            i+=1;
+            while i < n && !is_local_max(i) {
+                i+=1;
+            }
+            if i == n { break;}
+            cur_local_max = prices[i];
+
+            local_mins.push(cur_local_min);
+            local_maxs.push(cur_local_max);
+        }
+        // println!("local_mins={:?}, local_maxs={:?}", local_mins, local_maxs);
+        let mut sum : i32 = 0;
+        for i in 0..local_maxs.len() {
+            sum += local_maxs[i] - local_mins[i];
+        }
+        sum
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_122() {
+        assert_eq!(Solution::max_profit(vec![7, 1, 5, 3, 6, 4]), 7);
+        assert_eq!(Solution::max_profit(vec![1, 2, 3, 4, 5]), 4);
+        assert_eq!(Solution::max_profit(vec![2, 2, 5]), 3);
+    }
+}

src/problem/p0123_best_time_to_buy_and_sell_stock_iii.rs

@@ -0,0 +1,71 @@
+/**
+ * [123] Best Time to Buy and Sell Stock III
+ *
+ * You are given an array prices where prices[i] is the price of a given stock on the i^th day.
+ * Find the maximum profit you can achieve. You may complete at most two transactions.
+ * Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+ *  
+ * Example 1:
+ * 
+ * Input: prices = [3,3,5,0,0,3,1,4]
+ * Output: 6
+ * Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+ * Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
+ * Example 2:
+ * 
+ * Input: prices = [1,2,3,4,5]
+ * Output: 4
+ * Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+ * Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+ * 
+ * Example 3:
+ * 
+ * Input: prices = [7,6,4,3,1]
+ * Output: 0
+ * Explanation: In this case, no transaction is done, i.e. max profit = 0.
+ * 
+ * Example 4:
+ * 
+ * Input: prices = [1]
+ * Output: 0
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= prices.length <= 10^5
+ * 	0 <= prices[i] <= 10^5
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/
+// discuss: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>) -> i32 {
+        let n = prices.len();
+        let mut balances : Vec<Vec<i32>> = vec![vec![0;n];3];
+        for k in 1..=2 {
+            let mut min = prices[0];
+            for i in 1..n {
+                min = std::cmp::min(min, prices[i]-balances[k-1][i-1]);
+                balances[k][i] = std::cmp::max(balances[k][i-1], prices[i] - min);
+            }
+        }
+        balances[2][n-1]
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_123() {
+        assert_eq!(Solution::max_profit(vec![3, 3, 5, 0, 0, 3, 1, 4]), 6);
+    }
+}