力扣 1和0问题

本文探讨如何使用动态规划解决一个与0-1背包类似的问题,即在给定二进制字符串数组中找到包含最多m个0和n个1的子集。通过实例分析和C语言代码实现,提供了一种有效的解题思路。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:
给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的大小,该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素,集合 x 是集合 y 的 子集 。

示例 1:

输入:strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出:4
解释:最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ,因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意,因为它含 4 个 1 ,大于 n 的值 3 。

示例 2:

输入:strs = [“10”, “0”, “1”], m = 1, n = 1
输出:2
解释:最大的子集是 {“0”, “1”} ,所以答案是 2 。

提示:

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 ‘0’ 和 ‘1’ 组成
1 <= m, n <= 100

**

解题思路

本题与 0-1 背包问题很相似,只不过:

1.将一个背包容量变成了两个容量,对应的动态规划使用的 d p dpdp 数组也要相应地增加一维;
2.每个字符串的价值都是 1。
c语言代码

#define MAX(x, y) ((x) > (y)) ? (x) : (y)

int findMaxForm(char ** strs, int strsSize, int m, int n)
{
    int i,j,k;
    int dp[strsSize+1][m+1][n+1];
    int nums[strsSize][2];
    for(i=0;i<strsSize;++i)
    {
        nums[i][0]=0;
        nums[i][1]=0;
        for(j=0;j<strlen(strs[i]);j++)
        {
            if(strs[i][j]=='1')
            {
                nums[i][1]++;
            }
            else
            {
                nums[i][0]++;
            }
        }
    }
    for(i=0;i<=m;i++)
    {   
        for(j=0;j<=n;j++)
        {
            dp[0][i][j] = 0;
        }
    }
    for(i=1;i<=strsSize;i++)
    {
        for(j=0;j<=m;j++)
        {
            for(k=0;k<=n;k++)
            {
                if(nums[i-1][0]<=j && nums[i-1][1]<=k)
                {
                    dp[i][j][k]=MAX(dp[i-1][j][k],dp[i-1][j-nums[i-1][0]][k-nums[i-1][1]]+1);
                }
                else
                {
                    dp[i][j][k]=dp[i-1][j][k];
                }
            }
        }
    }
    return dp[strsSize][m][n];
}

执行结果
在这里插入图片描述

<think>好的,用户需要查找LeetCode上跳跃问题的C++解决方案。首先,我得明确用户具体指的是哪一个跳跃问题。因为LeetCode上有几个类似的题目,比如“跳跃游戏”(Jump Game)“跳跃游戏II”(Jump Game II)。根据用户提到的动态规划问题,以及引用[1]中的描述,应该是“跳跃游戏”,也就是判断能否到达最后一个位置的问题。 接下来,我需要回顾这个问题的解决方法。根据常见的解法,通常有贪心算法动态规划两种方法。动态规划可能会比较直观,但时间复杂度较高;而贪心算法更高效,可以在O(n)时间内解决问题。用户可能更希望看到最优的解法,所以优先考虑贪心算法。 然后,我需要确认用户需要的是C++的实现。引用[2]中提供了一个C++的数组旋转例子,这可以作为代码风格的参考。因此,在编写代码时,应保持类似的风格,使用vector,包含必要的头文件,并给出一个类或者函数的实现。 现在,需要构建解决方案的步骤。对于跳跃游戏问题,贪心算法的核心是维护一个最远可达的位置,遍历数组时更新这个值。如果当前位置超过了最远可达位置,说明无法到达终点。否则,在遍历结束后判断最远可达位置是否大于等于终点索引。 接下来,需要将这一思路转化为C++代码。确保代码结构清晰,注释到位,便于用户理解。同时,按照引用[2]中的示例,可能使用类Solution,并在其中定义成员函数canJump。测试用例部分也需要简单展示如何使用这个函数。 另外,用户可能对算法的时间复杂度空间复杂度感兴趣,所以需要补充这部分的分析。贪心算法的时间复杂度是O(n),空间复杂度是O(1),这是最优的解决方案。 最后,生成相关问题,帮助用户进一步学习。可能需要包括动态规划与贪心的对比、跳跃游戏II的解法、优化方法等。确保问题相关且有引导性,促进用户深入探索。 检查LaTeX格式是否符合要求,数学表达式是否正确使用$...$。例如,数组索引i,最远位置max_reach等不需要数学格式,但如果有方程或复杂表达式则需处理。当前问题中可能不需要太多数学公式,但如果有的话,如max_reach的更新规则,可以用$max\_reach = \max(max\_reach, i + nums[i])$。 总结整个思考过程,确保回答结构清晰,代码正确,引用正确添加,并生成相关问题。</think>关于LeetCode跳跃游戏问题的C++解决方案,以下是详细实现与分析: ### 问题描述 给定非负整数数组$nums$,每个元素表示在当前位置能跳跃的最大长度。判断从第一个位置出发,能否到达最后一个位置(索引$n-1$)。 ### 贪心算法实现(最优解) 这是时间复杂度$O(n)$、空间复杂度$O(1)$的高效解法: ```cpp #include <vector> using namespace std; class Solution { public: bool canJump(vector<int>& nums) { int max_reach = 0; // 当前能到达的最远位置 for (int i = 0; i < nums.size(); ++i) { if (i > max_reach) return false; // 当前位置不可达 max_reach = max(max_reach, i + nums[i]); if (max_reach >= nums.size() - 1) return true; // 提前终止条件 } return true; } }; ``` ### 算法解析 1. **核心思想**:维护当前能到达的最远位置$max\_reach$ 2. **终止条件**: - 当遍历到$i > max\_reach$时说明存在无法跨越的缺口 - 当$max\_reach \geq n-1$时提前返回成功 3. **正确性证明**:通过不断扩展可达范围,最终覆盖终点即成功[^1] ### 动态规划解法对比 虽然贪心算法更优,但动态规划解法有助于理解问题本质: ```cpp bool canJump_DP(vector<int>& nums) { vector<bool> dp(nums.size(), false); dp[0] = true; for (int i = 0; i < nums.size(); ++i) { if (!dp[i]) continue; for (int j = 1; j <= nums[i] && i+j < nums.size(); ++j) dp[i+j] = true; } return dp.back(); } ``` 时间复杂度$O(n^2)$,空间复杂度$O(n)$,适用于教学演示但实际效率较低[^2]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值