leetcode动态规划

416：分割等和子集

将其看成01背包，其中dp[j]的意义是最大可以凑成总容量J的最大和dp[j]，其中j遍历注意不要小于nums[i]

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int m=nums.size();
        int sum=0;
        for(int i=0;i<m;i++){
            sum+=nums[i];
        }
        if(sum%2!=0) return false;
        vector<int> dp(sum/2+1,0);
        dp[0]=0;
        for(int i=0;i<nums.size();i++){
            for(int j=sum/2;j>=nums[i];j--){
                dp[j]=max(dp[j],dp[j-nums[i]]+nums[i]);
            }
        }
        if(dp[sum/2]==sum/2) return true;
        return false;
    }
};

1049:最后一块石头的重量

动态规划，注意要给dp赋初值

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

494：目标和

巧妙转换假设加法的总和为x，那么减法对应的总和就是sum - x。

所以我们要求的是 x - (sum - x) = S

x = (S + sum) / 2

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int m=nums.size();
        if(m==0) return 0;
        int sum=0;
        for(int i=0;i<m;i++){
            sum+=nums[i];
        }
        if(S>sum) return 0;
        if((S+sum)%2==1) return 0;
        int s=(S+sum)/2;
        vector<int> dp(s+1,0);
        dp[0]=1;
        for(int i=0;i<nums.size();i++){
            for(int j=s;j>=nums[i];j--){
                dp[j]+=dp[j-nums[i]];
            }
        }
        return dp[s];
    }
};

343：整数拆分

动态规划，注意！！！一定要观察，dp[i]是对i进行拆分的最大乘积，找到对应的递推关系

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),j*dp[i-j]));
            }
        }
        return dp[n];
    }
};

474:一和零

96：不同的二叉搜索树

动态规划！dp[i]为i对应的二叉搜索树的数量，j为遍历头结点数量

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=1;j<=i;j++){
                dp[i]+=dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
};