Leetcode Best Time to Buy and Sell Stock IV problem solution

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:

        if k == 0 or len(prices) == 0:
            return 0

        min_price, profit = [float('inf')] * k, [float('-inf')] * k
        for price in prices:
            min_price[0] = min(min_price[0], price)
            profit[0] = max(profit[0], price - min_price[0])
            for i in range(1, k):
                min_price[i] = min(min_price[i], price - profit[i-1])
                profit[i] = max(profit[i], price - min_price[i])
        
        return profit[k-1]

class Solution {
    public int maxProfit(int k, int[] prices) {
        if(k==0 || prices.length==0)
            return 0;
        
        int[] cost = new int[k];
        int[] profits = new int[k];
        
        Arrays.fill(cost, Integer.MAX_VALUE);
        Arrays.fill(profits, 0);
        
        for(int price: prices){
            for(int i=0; i<k; i++){
                if(i==0){// first time buy the stock 
                    cost[i] = Math.min(cost[i], price);
                    profits[i] = Math.max(profits[i], price - cost[i] );
                }else{// from 2nd time to k times we should buy from previous profits
                    cost[i] = Math.min(cost[i], price - profits[i-1]);
                    profits[i] = Math.max(profits[i], price - cost[i] );
                }
            }   
        }    
        
        return profits[k-1];
    }
}

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n=prices.size();
        if(n==0){
            return 0;
        }
        int dp[k+1][n];
        
        for(int t=0;t<=k;t++){
            for(int d=0;d<n;d++){
                dp[t][d]=0;
            }
        }
        
        for(int t=1;t<=k;t++){
            int ans=INT_MIN;
            for(int d=1;d<n;d++){
                ans=max(ans,dp[t-1][d-1]-prices[d-1]);
                dp[t][d]=max(dp[t][d-1],ans+prices[d]);
            }
        }
        
        return dp[k][n-1];
    }
};

int max(int a, int b)
{
    return a > b ? a : b;
}

int maxProfit2(int* prices, int pricesSize)
{
    if(pricesSize == 1)
    {
        return 0;
    }
    
    int maxprofit = 0;
    
    for(int i = 1; i < pricesSize; ++i)
    {
        if(prices[i] - prices[i-1] > 0)
        {
            maxprofit = maxprofit + prices[i] - prices[i-1];
        }
    }
    
    return maxprofit;
}

int maxProfit(int k, int* prices, int pricesSize)
{
    if(pricesSize == 0)
    {
        return 0;
    }
    
    if(k > pricesSize)
    {
        return maxProfit2(prices, pricesSize);
    }
    
    int* global = (int*)malloc(sizeof(int) * (k+1));
    int* local = (int*)malloc(sizeof(int) * (k+1));
    
    for(int i = 0; i < k + 1; ++i)
    {
        global[i] = 0;
        local[i] = 0;
    }
    
    for(int i = 0; i < pricesSize - 1; ++i)
    {
        int diff = prices[i+1] - prices[i];
        
        for(int j = k; j >= 1; --j)
        {
            local[j] = max(global[j-1] + max(diff, 0), local[j] + diff);
            global[j] = max(global[j], local[j]);
        }
    }
    
    return global[k];
}