leecode 解题总结：188. Best Time to Buy and Sell Stock IV

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
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).

分析:此题必须计算至多k次交易的时候获取的最大利润。应该是动态规划。
设dp[i][k]:表示第截止到第i天（不包含第i天）的时候，交易k次获取的最大利润
最大利润来源于:1】前面i-1天就已经交易了k次，此时利用前i-1天的最大利润
2】为前面第j天交易了k-1次，再进行一次：第j天买入，第i天卖出的交易，其中j属于[0 , i-1]
dp[i][k] = max{ dp[i-1][k] , dp[j][k-1] + prices[i] - prices[j] }
= max { dp[i-1][k] , pricses[i] + max{ dp[j][k-1] - prices[j] }
dp[0][k] = 0,表示第0天，无论交易多少次，利润为0
dp[i][0] = 0,任意第i天，交易0次，利润肯定为0.

最后遍历dp[i][j]，寻找最大的数值即可

输入：
5(数组元素个数) 4(最多允许交易的次数)
1 2 3 -2 4
5 3
1 2 3 -2 4
5 2
1 2 3 -2 4
5 1
1 2 3 -2 4
5 2
1 -2 2 1 -3
1 2
-1
1 2
-1 -2
输出:
8
8
8
6
4
0
0

报错:
Runtime Error Message:
terminate called after throwing an instance of 'std::bad_alloc'
what():  std::bad_alloc
当k=1000000000时，我这个是三层循环，
说明应该不能分配内存的

关键:
1避免k过大，内存溢出
//这里如果超过1半数组元素个数，说明可以直接求两数之间正的差值作为利润
//应该是把出从较大到较小的这种情况屏蔽，比如 1 4 2,单调增的，则一次交易可涵盖多个
int sum = 0;
if(k >= size / 2)
{
for(int i = 1 ; i < size ; i++)
{
if(prices.at(i) > prices.at(i-1))
{
sum += ( prices.at(i) - prices.at(i-1) );
}
}
return sum;
}
2 另外，如果只有一个价格，肯定没有利润，而不是返回正数
*/

class Solution {
public:

int maxProfit(int k, vector<int>& prices) {
//如果只有一个价格，直接返回0，没有交易
if(prices.empty() || k <= 0 || 1 == prices.size())
{
return 0;
}

int size = prices.size();

//这里如果超过1半数组元素个数，说明可以直接求两数之间正的差值作为利润
//应该是把出从较大到较小的这种情况屏蔽，比如 1 4 2,单调增的，则一次交易可涵盖多个
int sum = 0;
if(k >= size / 2)
{
for(int i = 1 ; i < size ; i++)
{
if(prices.at(i) > prices.at(i-1))
{
sum += ( prices.at(i) - prices.at(i-1) );
}
}
return sum;
}

vector< vector<int> > dp( size + 1 , vector<int>(k + 1 , 0) ); //用vector溢出,改用new

int result = INT_MIN;
//dp[i][k] = max{ dp[i-1][k] , dp[j][k-1] + prices[i] - prices[j] }
for(int p = 1 ; p <= k ; p++)
{
int maxTemp = dp[0][p-1] - prices.at(0);
for(int i = 1 ; i < size ; i++)
{
maxTemp = max(maxTemp , dp[i-1][p-1] - prices[i-1]);
dp[i][p] = max( dp[i-1][p] , prices[i] + maxTemp );
result = max(result , dp[i][p]);
}
}
return result;
}
};

void print(vector<int>& result)
{
if(result.empty())
{
cout << "no result" << endl;
return;
}
int size = result.size();
for(int i = 0 ; i < size ; i++)
{
cout << result.at(i) << " " ;
}
cout << endl;
}

void process()
{
vector<int> nums;
int value;
int num;
Solution solution;
int result;
int maxTransactionTimes;
while(cin >> num >> maxTransactionTimes )
{
nums.clear();
for(int i = 0 ; i < num ; i++)
{
cin >> value;
nums.push_back(value);
}
result = solution.maxProfit(maxTransactionTimes , nums);
cout << result << endl;
}
}

int main(int argc , char* argv[])
{
process();
getchar();
return 0;
}