Introduction

In this blog post, we will explore how to solve the LeetCode problem "188" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are given an integer array prices where prices[i] is the price of a given stock on the ith day, and an integer k. Find the maximum profit you can achieve. You may complete at most k transactions: i.e. you may buy at most k times and sell at most k times. Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again). Example 1: Input: k = 2, prices = [2,4,1] Output: 2 Explanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2. Example 2: Input: k = 2, prices = [3,2,6,5,0,3] Output: 7 Explanation: Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3. Constraints: 1 <= k <= 100 1 <= prices.length <= 1000 0 <= prices[i] <= 1000

Explanation

Here's the solution to the stock trading problem with at most k transactions:

• Dynamic Programming: We use dynamic programming to build a table where dp[i][j] represents the maximum profit achievable with at most i transactions up to day j.
• Optimization: We optimize the space complexity by using only two rows of the dp table at a time, representing the current and previous states. This is done because to calculate the ith transaction only i-1th transaction is required.

• Base Cases: We initialize the first row of the dp table to 0, as no profit can be made with 0 transactions.

• Runtime Complexity: O(k*n), where n is the length of the prices array. Storage Complexity: O(n).

Code

    def max_profit(k: int, prices: list[int]) -> int:
    """
    Calculates the maximum profit that can be achieved with at most k transactions.

    Args:
        k: The maximum number of transactions allowed.
        prices: A list of stock prices for each day.

    Returns:
        The maximum profit that can be achieved.
    """

    n = len(prices)

    if n <= 1:
        return 0

    if k >= n // 2:
        profit = 0
        for i in range(1, n):
            diff = prices[i] - prices[i - 1]
            if diff > 0:
                profit += diff
        return profit

    dp = [[0] * n for _ in range(k + 1)]

    for i in range(1, k + 1):
        max_diff = -prices[0]
        for j in range(1, n):
            dp[i][j] = max(dp[i][j - 1], prices[j] + max_diff)
            max_diff = max(max_diff, dp[i - 1][j - 1] - prices[j])

    return dp[k][n - 1]