代码随想录二刷day43

乱世在摸鱼

已于 2023-09-27 10:13:58 修改

阅读量114

点赞数

分类专栏：力扣题解文章标签：算法数据结构动态规划 java leetcode

于 2023-09-27 10:12:39 首次发布

本文链接：https://blog.csdn.net/ResNet156/article/details/133274237

版权

力扣题解专栏收录该内容

272 篇文章 0 订阅

订阅专栏

本文介绍了力扣编程平台上的三个问题，分别是1049号题目（石头重量II）的动态规划解法，494号题目（目标和）的背包问题解决方案，以及474号题目（一和零）的字符串组合优化。展示了如何使用动态规划来解决这些问题。

摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

一、力扣1049. 最后一块石头的重量 II

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int count = 0;
        for(int a : stones){
            count += a;
        }
        int[] dp = new int[count/2+1];
        for(int i = 0; i < stones.length; i ++){
            for(int j = dp.length-1; j >= stones[i]; j --){
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return count - (2 * dp[dp.length-1]);
    }
}

二、力扣494. 目标和

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        //dp数组含义，填满背包容量为dp[i]有多少种方法
        int sum = 0;
        for(int a : nums){
            sum += a;
        }
        if(sum < Math.abs(target)){
            return 0;
        }
        if((sum + target) % 2 == 1){
            return 0;
        }
        int left = (sum + target)/2;
        if(left < 0){
            left  = -left;
        }
        int[] dp = new int[left + 1];
        dp[0] = 1;
        for(int i = 0; i < nums.length; i ++){
            for(int j = left; j >= nums[i]; j --){
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[left];
    }
}

三、力扣474. 一和零

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        for(String s : strs){
            int zeroSize = 0;
            int oneSize = 0;
            for(char ch : s.toCharArray()){
                if(ch == '0'){
                    zeroSize ++;
                }else{
                    oneSize ++;
                }
            }
            for(int i = m; i >= zeroSize; i --){
                for(int j = n; j >= oneSize; j --){
                    dp[i][j] = Math.max(dp[i][j], dp[i-zeroSize][j-oneSize]+1);
                }
            }
        }
        return dp[m][n];
    }
}