leetcode笔记—关于动态规划

动态规划的思路：找到DP（1），DP（2）,DP（n）与DP（n-1）、DP(n-2)的关系

1

class Solution {
public:
    int integerBreak(int n) {
        if(n==2)    return 1;  
        if(n==3)    return 2;  
        vector Dp(n+1,0);  
        Dp[0] = 1;Dp[1] = 1;  
        Dp[2] = 2;Dp[3] = 3;  
        for(int i=4; i<=n; ++i){  
                Dp[i] = max(Dp[i/2]*Dp[i-i/2],max(Dp[i-3]*Dp[3],Dp[i-2]*Dp[2]));//两边尽量相等时乘积最大  
        }  
        return Dp[n];  
    }
};

2. Coin Change

class Solution {
public:
const int INF = 0x7ffffffe;
    int coinChange(vector& coins, int amount) {
        // 无效输入的处理
        if (amount == 0)
            return 0;
        if (coins.size() == 0)
            return -1;
            
        vector dp(amount+1,0);
        for (int i = 1; i <= amount; i++) {
            int min1= INF;
            for (int j = 0; j < coins.size(); j++) {
                if (i >= coins[j] && dp[i - coins[j]] != -1)
                    min1= min(min1, dp[i - coins[j]] + 1);
            }
            
            // 根据min的值判断是否能兑换
            dp[i] = min1 == INF ? -1 : min1;
        }
        return dp[amount];
    }
};

3. Climbing Stairs

有n个台阶每次可以走一个或者两个，有多少种走法？

DP（1）=1，DP（2）=2，DP（n）=DP（n-1）+DP（n-2）

class Solution {
public:
    int climbStairs(int n) {
        vector dp(n);
        if(n<=2) return n;
        else
        {
            dp[0]=1;
            dp[1]=2;
            for(int i=2;i

3. Unique Paths

开一个f[m][n]的数组，f[i][j] = f[i-1][j] + f[i][j-1]，空间时间复杂度O(m*n)。用滚动数组空间复杂度可降为O(n)

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector > f(m, vector(n));
        for(int i=0;i

4. Unique Paths 2

有障碍

[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

class Solution {
public:
    int uniquePathsWithObstacles(vector>& obstacleGrid) {
        vector > f(obstacleGrid.size(), vector(obstacleGrid[0].size()));
        f[0][0]=obstacleGrid[0][0]==1 ? 0:1;
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        for(int i=1;i

4.Burst Balloons 重点 难点

class Solution {
public:
    int maxCoins(vector& nums) {
        int n=nums.size();
        nums.insert(nums.begin(), 1);
        nums.push_back(1);
        vector> dp(nums.size(), vector(nums.size(), 0));
       for (int len = 1; len <= n; ++len)
            for (int left = 1; left <= n - len + 1; ++left) {
                int right = left + len - 1;
                for (int k = left; k <= right; ++k)
                    dp[left][right] = max(dp[left][right], nums[left-1]*nums[k]*nums[right+1] + dp[left][k-1] + dp[k+1][right]);
            }
        return dp[1][n];
    }
};