LeetCode刷题指南:动态规划系列

62.不同路径

class Solution {
public:
    int uniquePaths(int m, int n) {
        ///注意声明一个二维vector的办法
        if(m == 0 || n == 0)
            return 0;
        if(m == 1 || n == 1)
            return 1;
        vector<vector<int> > v(m,vector<int>(n,1));
        for(int i = 1;i< m;i++)
        {
            for(int j = 1;j<n;j++)
            {
                v[i][j] = v[i-1][j]+v[i][j-1];
            }
        }
        return v[m-1][n-1];
    }
};

279.完全平方数

动态规划解法：

思路：dp[i] = min(dp[j] + dp[i-j],dp[i])

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1,INT_MAX);
        dp[1] = 1;
        for(int i = 0;i<=n;i++)
        {
            int t = sqrt(i);
            if(t*t == i)
                dp[i] = 1;
            else
            {
                for(int j = 1;j<=i/2;j++)
                {
                    dp[i] = min(dp[j] + dp[i-j],dp[i]);
                }
            }
        }
        return dp[n];
    }
};

其他解法：四平方定理

思路：任何一个数满足n=4^a(8b+7)都可以表示成四个平方数的和，只要满足这个条件返回4，否则判断能否由2个或1个平方数组成，不能的话最后返回3

class Solution {
public:
    int numSquares(int n) {
        while(n%4 == 0)
            n = n/4;
        while(n % 8 == 0)
            return 4;
        int a = 0;
        while(a*a <= n)
        {
            int b = sqrt(n-a*a);
            if(a*a + b*b == n)
                return !!a + !!b;
            a++;
        }
        return 3;

    }
};

123.买卖股票的最佳时机III

思路：维护两个量

当前到达第i天可以最多进行j次交易，最好的利润是多少

global[i][j]=max(local[i][j],global[i-1][j])

当前到达第i天，最多可进行j次交易，并且最后一次交易在当天卖出的最好的利润是多少

local[i][j]=max(global[i-1][j-1]+max(diff,0),local[i-1][j]+diff)

详细内容参见：https://blog.csdn.net/linhuanmars/article/details/23236995

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0)
            return 0;
        vector<int> local(3,0);
        vector<int> global(3,0);
        for(int i = 0;i< prices.size()-1;i++)
        {
            int diff = prices[i+1] - prices[i];
            for(int j = 2;j>=1;j--)
            {
                local[j] = max(global[j-1] + max(diff,0),local[j] + diff);
                global[j] = max(local[j],global[j]);
            }
        }
        return global[2];
    }
};

309.最佳买卖股票时机含冷冻期

思路：

概括为两种状态：第i天未持有股票和第i天持有股票

第i天未持有股票：保持之前的状态或者第i天卖出股票dp1[i] = max(dp1[i-1],dp2[i-1] + p[i])

第i天持有股票：保持之前的状态或者第i天买入股票dp2[i] = max(dp2[i-1],dp1[i-2]-p[i])

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0)
            return 0;
        vector<int> dp1(prices.size());
        vector<int> dp2(prices.size());
        dp2[0] = -prices[0];
        for(int i = 1;i<prices.size();i++)
        {
            dp1[i] = max(dp1[i-1],dp2[i-1] + prices[i]);
            dp2[i] = max(dp2[i-1],-prices[i]+(i>=2?dp1[i-2]:0));
        }
        return max(dp1[prices.size()-1],dp2[prices.size()-1]);
    }
};

714. 买卖股票的最佳时机含手续费

两种方法，思路一样，维护两种变量，一种是第i天手上没有股票（维持或者当天卖出），另外一种是第i天手上持有股票（维持或者当天买入）

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        if(prices.size() == 0)
            return 0;
        vector<int> dp1(prices.size(),0);  ///第i天手上持有股票，之前买进了或者当天买进
        vector<int> dp2(prices.size(),0);  ///第i天手上没有股票，当天卖出或者保持之前的状态

        dp1[0] = -prices[0];

        for(int i = 1;i<prices.size();i++)
        {
            dp1[i] = max(dp1[i-1],dp2[i-1]-prices[i]);
            dp2[i] = max(dp2[i-1],dp1[i-1]+prices[i]-fee);
        }
        return max(dp1[prices.size()-1],dp2[prices.size()-1]);
    }
};


class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        if(prices.size() == 0)
            return 0;
        int cash,buy;
        cash = 0;
        buy = -prices[0];
        for(int i = 1;i<prices.size();i++)
        {
            cash = max(cash,buy+prices[i]-fee);
            buy = max(buy,cash-prices[i]);
        }
        return max(cash,buy);
    }
};