refactor(algorithms, dynamic-programming): buy and sell stock 3

Author: BrianLusina

algorithms/dynamic_programming/buy_sell_stock/README.md

@@ -86,6 +86,58 @@ Output: 0
 Explanation: In this case, no transaction is done, i.e. max profit = 0.
 ```
 
+## Solution
+
+The solution uses a constant space, state-compressed dynamic programming approach to compute the maximum profit
+achievable, with at most 2 stock transactions in a single pass through the prices array. The updates are performed each
+day greedily, but the underlying logic is dynamic programming: each variable represents the best possible outcome up to
+the current point and depends on previously computed states. The core intuition is to model the problem as moving through
+four logical states: the cost of the first buy, the profit after the first sell, the effective cost of the second buy
+(after reinvesting the first profit), and the profit after the second sell. By continuously updating these values as we
+scan prices, we always keep track of the best possible outcome to date. The key insight is that the cost of the second
+buy can be reduced by the profit earned from the first transaction, allowing the two transactions to be combined optimally
+without overlap. This approach avoids the use of explicit dynamic programming tables and achieves optimal efficiency.
+
+Now, let’s look at the steps of the solution:
+
+1. We initialize four variables: t1Cost and t2Cost to infinity to represent the minimum cost of the first and second
+   buys, and t1Profit and t2Profit to 0 to represent the maximum profit after the first and second sells.
+2. We iterate through each price[i] in the prices array.
+   - We update t1Cost to be the minimum of its current value and the current price, ensuring we always track the lowest
+     price to buy the first stock.
+   - We update t1Profit to be the maximum of its current value and the profit that would result from selling at the
+     current price after buying at t1Cost.
+   - Next, we update t2Cost to be the minimum of its current value and (price − t1Profit), which represents the
+     effective cost of buying the second stock after reinvesting the profit from the first transaction.
+   - We then update t2Profit to be the maximum of its current value and the profit that would result from selling at the
+     current price after the second buy.
+3. After all prices have been processed, t2Profit contains the maximum profit achievable with at most two non-overlapping
+   transactions, and we return this value.
+
+![Solution 1](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_1.png)
+![Solution 2](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_2.png)
+![Solution 3](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_3.png)
+![Solution 4](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_4.png)
+![Solution 5](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_5.png)
+![Solution 6](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_6.png)
+![Solution 7](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_7.png)
+![Solution 8](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_8.png)
+![Solution 9](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_9.png)
+![Solution 10](./images/solutions/best_time_to_buy_and_sell_stock_3_solution_10.png)
+
+### Time Complexity
+
+The time complexity of this solution is O(n), where n is the length of the input array prices. This is because the
+algorithm makes a single pass through the array and, for each price, performs a constant number of arithmetic operations
+and comparisons to update the four tracking variables. As no nested loops or additional passes are involved, the total
+running time grows linearly with the number of days.
+
+### Space Complexity
+
+The space complexity of this solution is O(1). The solution uses a fixed number of variables regardless of the input
+size. No additional data structures proportional to the input size are required, so the extra space used remains
+constant even as the input array grows.
+
 ---
 
 # Best Time To Buy and Sell Stock With Transaction Fee

algorithms/dynamic_programming/buy_sell_stock/__init__.py

@@ -78,12 +78,9 @@ def max_profit_2(prices: List[int]) -> int:
 
 
 def max_profit_3(prices: List[int]) -> int:
-    if not prices:
-        return 0
-
     number_of_prices = len(prices)
 
-    if number_of_prices < 2:
+    if not prices or number_of_prices < 2:
         return 0
 
     forward_profit, backward_profit = [0] * number_of_prices, [0] * number_of_prices
@@ -105,6 +102,38 @@ def max_profit_3(prices: List[int]) -> int:
     return profit
 
 
+def max_profit_3_state_compressed_dp(prices: List[int]) -> int:
+    # t1_cost: minimum price paid for the first buy
+    # t2_cost: effective minimum price paid for the second buy
+    #          (price reduced by the profit from the first transaction)
+    t1_cost, t2_cost = float("inf"), float("inf")
+
+    # t1_profit: maximum profit achievable after the first sell
+    # t2_profit: maximum profit achievable after the second sell
+    t1_profit, t2_profit = 0, 0
+
+    # Iterate through each day's stock price
+    for price in prices:
+        # Update the minimum cost of the first buy
+        # We always want to buy at the lowest price seen so far
+        t1_cost = min(t1_cost, price)
+
+        # Update the maximum profit after the first sell
+        # Selling today gives profit = price - t1_cost
+        t1_profit = max(t1_profit, price - t1_cost)
+
+        # Update the effective cost of the second buy
+        # The profit from the first transaction reduces the net cost
+        t2_cost = min(t2_cost, price - t1_profit)
+
+        # Update the maximum profit after the second sell
+        # Selling today after the second buy gives total profit
+        t2_profit = max(t2_profit, price - t2_cost)
+
+    # t2_profit contains the maximum profit with at most two transactions
+    return t2_profit
+
+
 def max_profit_with_fee(prices: List[int], fee: int) -> int:
     # initially, there is no cash
     initial_cash = -math.inf