给定一个数组price [] ，它表示不同天股票的价格，任务是使用最多允许两笔交易的交易来找到不同天买卖股票后的最大利润。
注意：您不能同时进行多个交易(即，必须先出售股票才能再次购买)。
例子：
Input: prices[] = {3, 3, 5, 0, 0, 3, 1, 4}
Output: 6
Explanation:
Buy on Day 4 and Sell at Day 6 => Profit = 3 – 0 = 3
Buy on Day 7 and Sell at Day 8 => Profit = 4 -1 = 3
Therefore, Total Profit = 3 + 3 = 6
Input: prices[] = {1, 2, 3, 4, 5}
Output: 4
Explanation:
Buy on Day 1 and sell at Day 6 => Profit = 5 -1 = 4
Therefore, Total Profit = 4
在本文中，我们已经使用O(N)空间中的动态编程讨论了此问题。
高效方法：这里使用的想法是同时跟踪两个事务。两只股票的利润计算如下
- 首次交易的最大利润
- 找到我们必须从口袋里支付的最低价格(买入1)以获得第一只股票，这是当天或前一天的股票价格。
- 通过卖出当天的第一只股票来找到最大的利润。
- 第二笔交易的最大利润
- 我们必须从口袋里掏钱购买第二只股票的最低价格将是
buy2 = price[i] - profit1,
// Profit 1 is the profit from
// selling the first stock- 通过出售第二只股票来找到最大利润(profit2)。
举例说明：
Let us take price[] = { 3, 5, 4, 5}
We buy 1st stock on day 1
buy1 = 3.
We sell 1st stock on day 2.
profit1 = 5 – 3 = 2.
We will make a profit of 2 after buying the stock on 1st day and selling on 2nd day.
So, profit1 = 2
Now we will buy the 2nd stock on 3rd day
Stock price on 3rd day is 4
Since we already made a profit of 2, We will spend only 2 extra from our packet to buy the stock
i.e., (4 – profit1) = 2
buy2 = 2
Now, we will sell second stock on day 4.
Stock price on 4th day is 5.
profit2 = 5 – buy2 = 5 – 2 = 3.
Now, we can see that the final profit includes the profit of buying and selling two stocks
下面是上述方法的实现：
C++
// C++ implmenetation to find
// maximum possible profit
// with at most two transactions
#include
using namespace std;
// Function to find the maximum
// profit with two transactions
// on a given list of stock prices
int maxProfit(int price[], int n)
{
// buy1 - Money lent to buy 1 stock
// profit1 - Profit after selling
// the 1st stock buyed.
// buy2 - Money lent to buy 2 stocks
// including profit of selling 1st stock
// profit2 - Profit after selling 2 stocks
int buy1, profit1, buy2, profit2;
// Set initial buying values to
// INT_MAX as we want to minimize it
buy1 = buy2 = INT_MAX;
// Set initial selling values to
// zero as we want to maximize it
profit1 = profit2 = 0;
for (int i = 0; i < n; i++) {
// Money lent to buy the stock
// should be minimum as possible.
// buy1 tracks the minimum possible
// stock to buy from 0 to i-1.
buy1 = min(buy1, price[i]);
// Profit after selling a stock
// should be maximum as possible.
// profit1 tracks maximum possible
// profit we can make from 0 to i-1.
profit1 = max(profit1, price[i] - buy1);
// Now for buying the 2nd stock,
// we will integrate profit made
// from selling the 1st stock
buy2 = min(buy2, price[i] - profit1);
// Profit after selling a 2 stocks
// should be maximum as possible.
// profit2 tracks maximum possible
// profit we can make from 0 to i-1.
profit2 = max(profit2, price[i] - buy2);
}
return profit2;
}
// Driver Code
int main()
{
int price[] = { 2, 30, 15, 10, 8, 25, 80 };
int n = sizeof(price) / sizeof(price[0]);
cout << "Maximum Profit = "
<< maxProfit(price, n);
return 0;
} Java
// Java implmenetation to find
// maximum possible profit
// with at most two transactions
import java.util.*;
class GFG{
// Function to find the maximum
// profit with two transactions
// on a given list of stock prices
static int maxProfit(int price[], int n)
{
// buy1 - Money lent to buy 1 stock
// profit1 - Profit after selling
// the 1st stock buyed.
// buy2 - Money lent to buy 2 stocks
// including profit of selling 1st stock
// profit2 - Profit after selling 2 stocks
int buy1, profit1, buy2, profit2;
// Set initial buying values to
// Integer.MAX_VALUE as we want to
// minimize it
buy1 = buy2 = Integer.MAX_VALUE;
// Set initial selling values to
// zero as we want to maximize it
profit1 = profit2 = 0;
for(int i = 0; i < n; i++)
{
// Money lent to buy the stock
// should be minimum as possible.
// buy1 tracks the minimum possible
// stock to buy from 0 to i-1.
buy1 = Math.min(buy1, price[i]);
// Profit after selling a stock
// should be maximum as possible.
// profit1 tracks maximum possible
// profit we can make from 0 to i-1.
profit1 = Math.max(profit1, price[i] - buy1);
// Now for buying the 2nd stock,
// we will integrate profit made
// from selling the 1st stock
buy2 = Math.min(buy2, price[i] - profit1);
// Profit after selling a 2 stocks
// should be maximum as possible.
// profit2 tracks maximum possible
// profit we can make from 0 to i-1.
profit2 = Math.max(profit2, price[i] - buy2);
}
return profit2;
}
// Driver Code
public static void main(String[] args)
{
int price[] = { 2, 30, 15, 10, 8, 25, 80 };
int n = price.length;
System.out.print("Maximum Profit = " +
maxProfit(price, n));
}
}
// This code is contributed by Rajput-JiPython3
# Python3 implmenetation to find
# maximum possible profit
# with at most two transactions
import sys
# Function to find the maximum
# profit with two transactions
# on a given list of stock prices
def maxProfit(price, n):
# buy1 - Money lent to buy 1 stock
# profit1 - Profit after selling
# the 1st stock buyed.
# buy2 - Money lent to buy 2 stocks
# including profit of selling 1st stock
# profit2 - Profit after selling 2 stocks
# Set initial buying values to
# INT_MAX as we want to minimize it
buy1, buy2 = sys.maxsize, sys.maxsize
# Set initial selling values to
# zero as we want to maximize it
profit1, profit2 = 0, 0
for i in range(n):
# Money lent to buy the stock
# should be minimum as possible.
# buy1 tracks the minimum possible
# stock to buy from 0 to i-1.
buy1 = min(buy1, price[i])
# Profit after selling a stock
# should be maximum as possible.
# profit1 tracks maximum possible
# profit we can make from 0 to i-1.
profit1 = max(profit1, price[i] - buy1)
# Now for buying the 2nd stock,
# we will integrate profit made
# from selling the 1st stock
buy2 = min(buy2, price[i] - profit1)
# Profit after selling a 2 stocks
# should be maximum as possible.
# profit2 tracks maximum possible
# profit we can make from 0 to i-1.
profit2 = max(profit2, price[i] - buy2)
return profit2
# Driver code
price = [ 2, 30, 15, 10, 8, 25, 80 ]
n = len(price)
print("Maximum Profit = ", maxProfit(price, n))
# This code is contributed by divyeshrabadiya07C#
// C# implmenetation to find
// maximum possible profit
// with at most two transactions
using System;
class GFG{
// Function to find the maximum
// profit with two transactions
// on a given list of stock prices
static int maxProfit(int []price, int n)
{
// buy1 - Money lent to buy 1 stock
// profit1 - Profit after selling
// the 1st stock buyed.
// buy2 - Money lent to buy 2 stocks
// including profit of selling 1st stock
// profit2 - Profit after selling 2 stocks
int buy1, profit1, buy2, profit2;
// Set initial buying values to
// int.MaxValue as we want to
// minimize it
buy1 = buy2 = int.MaxValue;
// Set initial selling values to
// zero as we want to maximize it
profit1 = profit2 = 0;
for(int i = 0; i < n; i++)
{
// Money lent to buy the stock
// should be minimum as possible.
// buy1 tracks the minimum possible
// stock to buy from 0 to i-1.
buy1 = Math.Min(buy1, price[i]);
// Profit after selling a stock
// should be maximum as possible.
// profit1 tracks maximum possible
// profit we can make from 0 to i-1.
profit1 = Math.Max(profit1, price[i] - buy1);
// Now for buying the 2nd stock,
// we will integrate profit made
// from selling the 1st stock
buy2 = Math.Min(buy2, price[i] - profit1);
// Profit after selling a 2 stocks
// should be maximum as possible.
// profit2 tracks maximum possible
// profit we can make from 0 to i-1.
profit2 = Math.Max(profit2, price[i] - buy2);
}
return profit2;
}
// Driver Code
public static void Main(String[] args)
{
int []price = { 2, 30, 15, 10, 8, 25, 80 };
int n = price.Length;
Console.Write("Maximum Profit = " +
maxProfit(price, n));
}
}
// This code is contributed by Rajput-Ji输出：
Maximum Profit = 100时间复杂度： O(N)
辅助空间： O(1)