714. Best Time to Buy and Sell Stock with Transaction Fee

Your are given an array of integers prices, for which the i-th element is the price of a given stock on day i; and a non-negative integer fee representing a transaction fee.

You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction. You may not buy more than 1 share of a stock at a time (ie. you must sell the stock share before you buy again.)

Return the maximum profit you can make.

Example 1:

Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
Output: 8
Explanation: The maximum profit can be achieved by:

Buying at prices[0] = 1Selling at prices[3] = 8Buying at prices[4] = 4Selling at prices[5] = 9The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

Note:

0 < prices.length <= 50000. 0 < prices[i] < 50000. 0 <= fee < 50000.

总感觉先求部分再合并的思路是不对的
以下是比赛是WA的code

package l714;

import java.util.ArrayList;
import java.util.List;

/**
 * 总感觉先求部分再合并的思路是不对的
 * @author lenovo
 *
 */
class WA {
    public int maxProfit(int[] prices, int fee) {
    	List<Integer> in = new ArrayList<Integer>(), out = new ArrayList<Integer>();
        int ret = 0;
        for(int i=0; i<prices.length; i++) {
        	int j = i+1, min = prices[i], minIdx = i;
        	for(; j<prices.length; j++) {
        		if(prices[j] < min) {
        			min = prices[j];
        			minIdx = j; 
        		}
        		if(prices[j] - min > fee)	break;
        	}
        	if(j < prices.length) {
//        		ret += Math.max(prices[j] - min - fee, fee);
//        		l.add(prices[j] - min - fee);
        		in.add(minIdx);
        		out.add(j);
        	}
        	i = j - 1;
        }
        
        for(int i=0; i<in.size(); i++) {
        	if(i == in.size()-1)	ret += prices[out.get(i)]-prices[in.get(i)]-fee;
        	else {
//        		ret += Math.max(prices[out.get(i)]-prices[in.get(i)]-fee, b)
        	}
        }
        
        if(in.size() > 0)	ret=prices[out.get(0)]-prices[in.get(0)]-fee;
        for(int i=1; i<in.size(); i++) {
        	ret += prices[out.get(i)]-prices[in.get(i)]-fee;
        	if(prices[out.get(i-1)] - prices[in.get(i)] < fee) {
        		ret += fee - prices[out.get(i-1)] + prices[in.get(i)];
        	}
        }
//        	if(l.get(i) - fee > fee)	ret += l.get(i);
//        	else				ret += l.get(i) + fee;
//        	ret += l.get(i) + Math.max(0, fee-l.get(i));
        return ret;
    }
}

正确的思路是DP，找每个节点的状态：没有stock和有stock

class Solution {
    public int maxProfit(int[] prices, int fee) {
    	int s0 = 0, s1 = Integer.MIN_VALUE;
    	for(int p : prices) {
    		int tmp = s0;
    		s0 = Math.max(s0, s1+p);
    		s1 = Math.max(s1, tmp-p-fee);
    	}
    	return s0;
    }
}

或者状态复杂点

This problem is just like the other stock problems.
At given day, we can do 1 out of 4 things:

buy stock
hold stock
do nothing with empty portfolio
sell stock
We have 4 arrays with the length of # of the days, recording the max profit at given day if we do given operation.

Here is the code:

class Solution {
    public int maxProfit(int[] prices, int fee) {
        if(prices.length <= 1) return 0;
        int[] buy = new int[prices.length];
        int[] hold = new int[prices.length];
        int[] skip = new int[prices.length];
        int[] sell = new int[prices.length];
        // the moment we buy a stock, our balance should decrease
        buy[0] = 0 - prices[0]; 
        // assume if we have stock in the first day, we are still in deficit
        hold[0] = 0 - prices[0];
        for(int i = 1; i < prices.length; i++){
            // We can only buy on today if we sold stock
            // or skipped with empty portfolio yesterday
            buy[i] = Math.max(skip[i-1], sell[i-1]) - prices[i]; 
            // Can only hold if we bought or already holding stock yesterday
            hold[i] = Math.max(buy[i-1], hold[i-1]);
            // Can skip only if we skipped, or sold stock yesterday
            skip[i] = Math.max(skip[i-1], sell[i-1]);
            // Can sell only if we bought, or held stock yesterday
            sell[i] = Math.max(buy[i-1], hold[i-1]) + prices[i] - fee;
        }
        // Get the max of all the 4 actions on the last day.
        int max = Math.max(buy[prices.length - 1], hold[prices.length - 1]);
        max = Math.max(skip[prices.length - 1], max);
        max = Math.max(sell[prices.length - 1], max);
        return Math.max(max, 0);
    }
}