188 Best Time to Buy and Sell Stock IV

188 Best Time to Buy and Sell Stock IV

连接：https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/
问题描述：
Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most k transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

Credits:
Special thanks to @Freezen for adding this problem and creating all test cases.

这个问题就是限定k次数的买卖股票的最大收益，其实是找数组中没有重叠部分的k个区间，使k个区间中末尾数字减去开头数字的和最大。解这个问题需要用动态规划。使用“局部最优和全局最优解法”。我们维护两种量，一个是当前到达第i天可以最多进行j次交易，最好的利润是多少（global[i][j]），另一个是当前到达第i天，最多可进行j次交易，并且最后一次交易在当天卖出的最好的利润是多少（local[i][j]）。下面我们来看递推式，全局的比较简单，
global[i][j]=max(local[i][j],global[i-1][j])，
也就是去当前局部最好的，和过往全局最好的中大的那个（因为最后一次交易如果包含当前天一定在局部最好的里面，否则一定在过往全局最优的里面）。对于局部变量的维护，递推式是
local[i][j]=max(global[i-1][j-1]+max(diff,0),local[i-1][j]+diff)，
也就是看两个量，第一个是全局到i-1天进行j-1次交易，然后加上今天的交易，如果今天是赚钱的话（也就是前面只要j-1次交易，最后一次交易取当前天），第二个量则是取local第i-1天j次交易，然后加上今天的差值（这里因为local[i-1][j]比如包含第i-1天卖出的交易，所以现在变成第i天卖出，并不会增加交易次数，而且这里无论diff是不是大于0都一定要加上，因为否则就不满足local[i][j]必须在最后一天卖出的条件了）。以上部分应用自一个博客：http://blog.csdn.net/linhuanmars/article/details/23236995，因为自己水平有限，等对动态规划理解更深，自己能讲清楚这个问题再来修改这里，争取自己讲清楚。
初级解法：

int max(int a,int b)
{
  return a>b? a:b;
}
int maxProfit(int k, int* prices, int pricesSize) 
{
    if(k<1||pricesSize<2) return 0;
    int profit=0;
    if(pricesSize*2<=k)
    {
       for(int i=1;i<pricesSize;i++)
      profit+=max(prices[i]-prices[i-1],0);
       return profit;
    }

    int **local=(int **)malloc(sizeof(int*)*k);
    int **global=(int**)malloc(sizeof(int*)*k);
    for(int i=0;i<k;i++)
    {
       local[i]=(int *)malloc(sizeof(int)*(pricesSize));
       global[i]=(int *)malloc(sizeof(int)*(pricesSize));
       local[i][0]=0;
       global[i][0]=0;
    }

    for(int i=1;i<pricesSize;i++)
    {
      int pro=prices[i]-prices[i-1];
      for(int j=0;j<k;j++)
      {
          if(j==0)
        local[j][i]=max(max(pro,0),local[j][i-1]+pro);
          else
       local[j][i]=max(global[j-1][i-1]+max(pro,0),local[j][i-1]+pro);
       global[j][i]=max(local[j][i],global[j][i-1]);
      }
    }

    profit=  global[k-1][pricesSize-1];

    for(int i=0;i<k;i++)
    {
       free(local[i]);
       free(global[i]);
    }
    free(local);
    free(global);
    return profit;
}

改进的解法：

int max(int a,int b)
    {
      return a>b? a:b;
    }
int maxProfit(int k, int* prices, int pricesSize) 
{
    if(k<1||pricesSize<2) return 0;
    int profit=0;
    if(pricesSize*2<=k)
    {
       for(int i=1;i<pricesSize;i++)
       profit+=max(prices[i]-prices[i-1],0);
       return profit;
    }

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

    profit=  global[k-1];
    free(local);
    free(global);
    return profit;
}

这里第二个解法提交到leetcode中时竟然是 Wrong Answer，

可是我实际在vs2012中测试时结果是24，不是32，可能是编译器标准不一致所致。