LeetCode 动态规划（DP）题单

代码随想录——LeetCode DP题单

整数划分

LeetCode 343 整数划分

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1);
        dp[2] = 1;
        for(int i = 3; i <= n; i++) {
            for(int j = 1; j <= i-1 ; j++) {
                dp[i] = max(dp[i],max(j*(i-j),dp[i-j]*j));
            }
        }
        return dp[n];
    }
};

不同的二叉搜索树

LeetCode 96 不同的二叉搜索树

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n+1);
        dp[0] = 1;
        for(int i = 1; i <= n; i++) {
            for(int j = 0; j <= i-1 ; j++) {
                dp[i] += dp[j]*dp[i-j-1];
            }
        }
        return dp[n];
    }
};

分割等和子集

LeerCode 416 分割等和子集

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        vector<int> dp(10001);
        for(int i = 0; i  < nums.size(); i++) {
            sum += nums[i];
        }
        if(sum % 2 != 0 )
            return false;
        int res = sum/2;

        for(int i = 0; i < nums.size(); i++) {
            for(int j = res; j >= nums[i]; j--) {
                dp[j] = max(dp[j],dp[j-nums[i]] + nums[i]);
            }
        } 
        if(dp[res] == res) return true;
        return false;

    }
};

最后一块石头的重量 II

LeetCode 1049. 最后一块石头的重量 II

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(15001);
        int sum = 0;
        for(int i = 0; i < stones.size(); i++) {
            sum += stones[i];
        }
        int res = sum/2;
        for(int i = 0; i < stones.size(); i++) {
            for(int j = res; j >= stones[i]; j--) {
                dp[j] = max(dp[j],dp[j-stones[i]] + stones[i]);
            }
        }

        return sum - dp[res] - dp[res];
    }
};

目标和

LeetCode 494.目标和

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for(int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        if (abs(target) > sum) return 0; // 此时没有方案
        if ((target + sum) % 2 == 1) return 0; // 此时没有方案

        int res = (target + sum)/2;
        vector<int> dp(res + 1, 0);
        dp[0] = 1;
        for(int i = 0; i < nums.size(); i++) {
            for(int j = res; j >= nums[i]; j--) {
                dp[j] += dp[j-nums[i]];
            }
        }

        return dp[res];
    }
};

一和零

LeetCode 474.一和零

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int> (n + 1)); 
        for(string str:strs) {
            int zero = 0;
            int one = 0;
            for(char c : str) {
                if(c == '0') zero++;
                else one++;
            }
            for(int i = m; i >= zero; i--) {
                for(int j = n; j >= one; j--) {
                    dp[i][j] = max(dp[i][j],dp[i-zero][j-one]+1);
                }
            }
        }
        return dp[m][n];
    }
};

零钱兑换II

LeetCode 518.零钱兑换II

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount+1);
        dp[0] = 1;
        for(int i = 0; i < coins.size(); i++) {
            for(int j = coins[i]; j <= amount ;j++) {
                dp[j] += dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
};

组合总和 Ⅳ

LeetCode 377.组合总和 Ⅳ

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target + 1, 0);
        dp[0] = 1;
        for (int i = 0; i <= target; i++) { // 遍历背包
            for (int j = 0; j < nums.size(); j++) { // 遍历物品
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
};

零钱兑换

LeetCode 322.零钱兑换

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int Max = amount + 1;
        vector<int> dp(amount + 1, Max);
        dp[0] = 0;
        for (int i = 1; i <= amount; ++i) {
            for (int j = 0; j < coins.size(); ++j) {
                if (coins[j] <= i) {
                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        if(dp[amount] == amount +1) return -1;
        return dp[amount];
    }
};

完全平方数

LeetCode 279.完全平方数

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

单词拆分

LeetCode 139.单词拆分

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        vector<bool> dp(s.size() + 1, false);
        dp[0] = true;
        for (int i = 1; i <= s.size(); i++) {   
            for (int j = 0; j < i; j++) {      
                string word = s.substr(j, i - j); 
                if (wordSet.find(word) != wordSet.end() && dp[j]) {
                    dp[i] = true;
                }
            }
        }
        return dp[s.size()];
    }
};

打家劫舍

LeetCode 198.打家劫舍

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        if(nums.size() == 1) return nums[0];

        vector<int> dp(nums.size());
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i = 2; i < nums.size(); i++) {
            dp[i] = max(dp[i-2] + nums[i], dp[i-1]);
        }

        return dp[nums.size()-1];
    }
};

打家劫舍II

LeetCode 213.打家劫舍II

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        if(nums.size() == 1) return nums[0];
        int res1 = robRange(nums,0,nums.size()-2);
        int res2 = robRange(nums,1,nums.size()-1);
        return max(res1,res2);
    }

    int robRange(vector<int>& nums,int start,int end) {
        if(start == end) return nums[end];
        vector<int> dp(nums.size());
        dp[start] = nums[start];
        dp[start + 1] = max(nums[start], nums[start + 1]);
        for(int i = start + 2; i <= end; i++) {
             dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[end];
    }
};

打家劫舍III

LeetCode 337.打家劫舍III

class Solution {
public:
    unordered_map<TreeNode* , int> umap; // 记录计算过的结果
    int rob(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right == NULL) return root->val;
        if (umap[root]) return umap[root]; 
        // 偷父节点
        int val1 = root->val;
        if (root->left) val1 += rob(root->left->left) + rob(root->left->right); 
        if (root->right) val1 += rob(root->right->left) + rob(root->right->right);
        // 不偷父节点
        int val2 = rob(root->left) + rob(root->right); 
        umap[root] = max(val1, val2); 
        return max(val1, val2);
    }
};

买卖股票的最佳时机

LeetCode 121.买卖股票的最佳时机

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

股票买卖的最佳时机II

LeetCode 122.股票买卖的最佳时机II

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if(len == 0) return 0;

        vector<vector<int>> dp(len,vector<int>(2));
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        for(int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        return dp[len-1][1];
    }
};

买卖股票的最佳时机III

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

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if(len == 0) return 0;
        vector<vector<int>> dp(len,vector<int>(5));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];

        for(int i = 1; i < len; i++) {
            dp[i][0] = dp[i-1][0];
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i]);
            dp[i][2] = max(dp[i-1][2], dp[i-1][1]+prices[i]);
            dp[i][3] = max(dp[i-1][3], dp[i-1][2]-prices[i]);
            dp[i][4] = max(dp[i-1][4], dp[i-1][3]+prices[i]);

        }

        return dp[len-1][4];
    }
};

================================================
最后还有LCS的题目日后添加把