29303132333435363738394041

class StockProfit:
    def get_maximum_profit(self, arr):
        """
        Space-optimized bottom-up DP for maximum stock trading profit.
        :param arr: List of stock prices
        :return: Maximum profit achievable
        """
        n = len(arr)
        if n == 0:
            return 0

        # ahead → future profit (next day)
        # cur → current day's profit
        ahead = [0, 0]
        cur = [0, 0]

        # Iterate from last day to first
        for ind in range(n - 1, -1, -1):
            for buy in range(2):
                if buy == 0:
                    # Option 1: skip buying
                    # Option 2: buy today
                    profit = max(0 + ahead[0], -arr[ind] + ahead[1])
                else:
                    # Option 1: skip selling
                    # Option 2: sell today
                    profit = max(0 + ahead[1], arr[ind] + ahead[0])
                cur[buy] = profit

            # Move current results into ahead for the next iteration
            ahead = cur[:]

        return cur[0]


# Driver code
if __name__ == "__main__":
    sp = StockProfit()
    prices = [7, 1, 5, 3, 6, 4]
    print("The maximum profit that can be generated is", sp.get_maximum_profit(prices))

12345678910111213141516171819202122232425262728293031323334353637383940414243

class StockProfit {
    /**
     * Space-optimized DP for maximum stock trading profit
     * @param {number[]} arr - Stock prices array
     * @returns {number} Maximum achievable profit
     */
    getMaximumProfit(arr) {
        const n = arr.length;
        if (n === 0) return 0;

        // ahead → profit for the next day
        // cur → profit for the current day being processed
        let ahead = [0, 0];
        let cur = [0, 0];

        // Iterate from last day to first
        for (let ind = n - 1; ind >= 0; ind--) {
            for (let buy = 0; buy <= 1; buy++) {
                let profit;
                if (buy === 0) {
                    // Option 1: skip buying
                    // Option 2: buy today
                    profit = Math.max(0 + ahead[0], -arr[ind] + ahead[1]);
                } else {
                    // Option 1: skip selling
                    // Option 2: sell today
                    profit = Math.max(0 + ahead[1], arr[ind] + ahead[0]);
                }
                cur[buy] = profit;
            }
            // Update ahead for next iteration
            ahead = [...cur];
        }

        return cur[0];
    }
}

// Driver code
const sp = new StockProfit();
const prices = [7, 1, 5, 3, 6, 4];
console.log("The maximum profit that can be generated is", sp.getMaximumProfit(prices));

Complexity Analysis