[Coding Made Simple] Buy/Sell stock with at most K transactions to maximize profit

Given an array of length n that stores a stock's price in n consecutive days,  Buy/Sell stock with at most K transactions to maximize profit.

You must finish one transcation before you start the next transcation.

For some given prices of consecutive days prices[0 ~ i], on day i, we can either finish the last transcation by selling at prices[i], 

or we do not have any transcations happening on day i.

f(i, k) = max of {f(i - 1, k),   max of {prices[i] - prices[j] + f(j, k - 1),  j is from day 0 to day i - 1} }

since one transcation muse be finished before the next one starts, it means if we finish the kth transcation on day i, all the previous k - 1 transcations must happen before day i, excluding day i.

Solution 1. Recursion

public class StockTranscation {
      public int getMaxProfitRecursion(int[] prices, int k) {
          if(prices == null || prices.length <= 1 || k <= 0) {
              return 0;
          }
          return recursionHelper(prices, prices.length - 1, k);
      }
      private int recursionHelper(int[] prices, int day, int k) {
          if(day <= 0 || k == 0) {
             return 0;
         }
         int max = recursionHelper(prices, day - 1, k);
         for(int i = 0; i < day; i++) {
             max = Math.max(max, prices[day] - prices[i] + recursionHelper(prices, i, k - 1));
         }
         return max;
     }
     public static void main(String[] args) {
         int[] prices = {2,5,7,1,4,3,1,3};
         StockTranscation test = new StockTranscation();
         System.out.println(test.getMaxProfitDp(prices, 3));
     }
}

 Solution 2. Dynamic Programming, O(n * n * k) runtime, O(n*k) space

 public int getMaxProfitDp(int[] prices, int k) {
     if(prices == null || prices.length <= 1 || k <= 0) {
         return 0;
     }        
     int[][] profit = new int[k + 1][prices.length];
     //profit is 0 when there is 0 transcation
     for(int j = 0; j < prices.length; j++) {
        profit[0][j] = 0; 
     }
     //profit is 0 when there is the first day's stock price info
     for(int i = 0; i <= k; i++) {
         profit[i][0] = 0;
     }
     for(int i = 1; i <= k; i++) {
         for(int j = 1; j < prices.length; j++) {
             profit[i][j] = profit[i][j - 1];
             for(int t = 0; t < j; t++) {
                 profit[i][j] = Math.max(profit[i][j], prices[j] - prices[t] + profit[k - 1][t]);
             }
         }
     }
     return profit[k][prices.length - 1];
 }

Solution 3. Dynamic Programming, O(n * k) runtime, O(n * k) space