The DFS solution of leetcode 123, 188 stock trading problem template

Time:2021-4-29

The DFS solution of leetcode 123, 188 stock trading problem template
The DFS solution of leetcode 123, 188 stock trading problem template

The common point of these two problems is that there is a limit on the number of transactions, that is to say, there are two states changing: I (the current date is the index of the array) and K.

Here, the state of DFS is found, that is, the parameter of DFS function:
function dfs (i,k){}

Actually, it’s heredfs(i,k)It is equivalent to using DP array of dynamic programmingdp[i][k]

every lastdfs(i,k)There are two internal states, namely, owning stocks and not owning stocks.
NamelyFunction DFS (I, K) {return}

currentdfs(i,k)The value of shares owned is:dfs(i-1,k)(i.e. the day before)Stock ownership status value anddfs(i-1,k-1)The status value of not owning stock-prices[i], the best of both.

currentdfs(i,k)The value of non ownership is:dfs(i-1,k)Do not own stock status value anddfs(i-1,k)Owning stock status value+prices[i], the best of both.

The final result is:Trading K (or 2) times on the last day and not owning shares

Here is the code for 123. The best time to buy and sell stocks

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    //The solution of the stock problem template based on DFS
    //You can use memo to optimize or rewrite directly to DP
    function dfs(i,k){
        //Critical value
        if(i < 0 || k === 0) return [0,Number.MIN_SAFE_INTEGER]
        //In the case of current I K,
        //1. Non ownership of shares:
        //The best of the two: no stock the day before and stock the day before but sell today
        //2. Stock ownership:
        //There are stocks in the previous day and there are no stocks in the previous day, and they only trade k-1 times (because they will buy when there are no stocks in the previous day) 
        //The best of both
        const status_0 = Math.max(dfs(i-1,k)[0],dfs(i-1,k)[1]+prices[i])
        const status_1 = Math.max(dfs(i-1,k)[1],dfs(i-1,k-1)[0]-prices[i])
        return [status_0,status_1]
    }
    //The final result is the situation of trading twice on the last day and not owning stocks
    return dfs(prices.length-1,2)[0]

---------------------Dividing line-----------------------


    //Next, use the template optimized by DP
    const len = prices.length, dp = new Array(len)
    for(let i = 0; i<len; i++){
        dp[i] = new Array(3)
        dp[i][0] = [0,Number.MIN_SAFE_INTEGER]
    }
    dp[-1] = new Array(3)
    dp[-1].fill([0,Number.MIN_SAFE_INTEGER])
    for(let i = 0; i<len; i++){
        for(let j = 1; j<=2; j++){
            const status_0 = Math.max(dp[i-1][j][0],dp[i-1][j][1]+prices[i])
            const status_1 = Math.max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i])
            dp[i][j] = [status_0,status_1]
        }
    }
    return dp[len-1][2][0]
};

The best time to buy and sell stocks

This problem is similar to the problem, but the optimization is more difficult than the previous one. It’s easy to time out. DFS is as like as two peas.

/**
 * @param {number} k
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(k, prices) {
    //The solution of the stock problem template based on DFS
    //You can use memo to optimize or rewrite directly to DP
    function dfs(i,k){
        //Critical value
        if(i < 0 || k === 0) return [0,Number.MIN_SAFE_INTEGER]
        //In the case of current I K,
        //1. Non ownership of shares:
        //The best of the two: no stock the day before and stock the day before but sell today
        //2. Stock ownership:
        //There are stocks in the previous day and there are no stocks in the previous day, and they only trade k-1 times (because they will buy when there are no stocks in the previous day) 
        //The best of both
        const status_0 = Math.max(dfs(i-1,k)[0],dfs(i-1,k)[1]+prices[i])
        const status_1 = Math.max(dfs(i-1,k)[1],dfs(i-1,k-1)[0]-prices[i])
        return [status_0,status_1]
    }
    //The final result is the last day of trading K times and do not own stocks
    return dfs(prices.length-1,k)[0]
};