代码随想录刷题第42天

最新推荐文章于 2024-09-14 22:25:23 发布

气氛组阿宇

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量153

点赞数

文章标签：算法 leetcode 动态规划

本文链接：https://blog.csdn.net/Bi11y/article/details/129229626

版权

文章介绍了LeetCode上的两道算法题目，分别是最后一块石头的重量II和目标和。解决方案涉及到数组处理和动态规划，通过选取石头进行组合以达到特定目标，求解最优解。

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

代码随想录刷题第42天

最后一块石头的重量 II


/*

* @lc app=leetcode.cn id=1049 lang=cpp

*

* [1049] 最后一块石头的重量 II

*

* https://leetcode.cn/problems/last-stone-weight-ii/description/

*

* algorithms

* Medium (68.87%)

 * Likes:    615

* Dislikes: 0

 * Total Accepted:    106.4K

* Total Submissions: 154.3K

 * Testcase Example:  '[2,7,4,1,8,1]'

*

* 有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

* 

* 每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

* 

* 

* 如果 x == y，那么两块石头都会被完全粉碎；

* 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

* 

* 

* 最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

* 

* 

* 

* 示例 1：

* 

* 

* 输入：stones = [2,7,4,1,8,1]

* 输出：1

* 解释：

* 组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，

* 组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，

* 组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，

* 组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

* 

* 

* 示例 2：

* 

* 

* 输入：stones = [31,26,33,21,40]

* 输出：5

* 

* 

* 

* 

* 提示：

* 

* 

* 1 <= stones.length <= 30

* 1 <= stones[i] <= 100

* 

* 

*/

 

// @lc code=start

#include <vector>

#include <stdio.h>

#include <numeric>

using namespace std;

 

class Solution {

public:

    int lastStoneWeightII(vector<int>& stones) {

        int result;

        int sum = accumulate(stones.begin(),stones.end(),0);

        int target = sum / 2;

        vector<int> dp(target+1,0);

        for (int i = 0; i < stones.size(); i++)

        {

            for(int j = target; j >= stones[i] ; j--){

                dp[j] = max(dp[j],stones[i] + dp[j - stones[i]]);

            }

        }

        result = sum - 2 * dp[target];

        return result;

    }

};

// @lc code=end

494. 目标和


class Solution {

public:

    int findTargetSumWays(vector<int>& nums, int target) {

        int sum = 0;

        for (int& num : nums) {

            sum += num;

        }

        int diff = sum - target;

        if (diff < 0 || diff % 2 != 0) {

            return 0;

        }

        int n = nums.size(), neg = diff / 2;

        vector<vector<int>> dp(n + 1, vector<int>(neg + 1));

        dp[0][0] = 1;

        for (int i = 1; i <= n; i++) {

            int num = nums[i - 1];

            for (int j = 0; j <= neg; j++) {

                dp[i][j] = dp[i - 1][j];

                if (j >= num) {

                    dp[i][j] += dp[i - 1][j - num];

                }

            }

        }

        return dp[n][neg];

    }

};

474. 一和零


class Solution {

public:

    vector<int> getZerosOnes(string& str) {

        vector<int> zerosOnes(2);

        int length = str.length();

        for (int i = 0; i < length; i++) {

            zerosOnes[str[i] - '0']++;

        }

        return zerosOnes;

    }

 

    int findMaxForm(vector<string>& strs, int m, int n) {

        int length = strs.size();

        vector<vector<vector<int>>> dp(length + 1, vector<vector<int>>(m + 1, vector<int>(n + 1)));

        for (int i = 1; i <= length; i++) {

            vector<int>&& zerosOnes = getZerosOnes(strs[i - 1]);

            int zeros = zerosOnes[0], ones = zerosOnes[1];

            for (int j = 0; j <= m; j++) {

                for (int k = 0; k <= n; k++) {

                    dp[i][j][k] = dp[i - 1][j][k];

                    if (j >= zeros && k >= ones) {

                        dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - zeros][k - ones] + 1);

                    }

                }

            }

        }

        return dp[length][m][n];

    }

};