力扣刷题代码（暂时只有c++代码）

最新推荐文章于 2024-06-19 23:28:33 发布

The_All_one

最新推荐文章于 2024-06-19 23:28:33 发布

阅读量1k

点赞数

文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/qq_52988674/article/details/120494698

版权

本文探讨了三个与数组操作相关的算法问题：找出最长递增子序列的个数，解决俄罗斯套娃信封问题（信封叠放），以及求解最大子序和。通过实例和C++代码展示了如何高效解决这些经典问题，适合理解动态规划在实际问题中的应用。

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

最长递增子序列的个数

给定一个未排序的整数数组，找到最长递增子序列的个数。

示例 1:

输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。

示例 2:

输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。

注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。

C++代码：

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n);
        vector<int> count(n);

        for(int i = 0;i < n;i++)
        {
            dp[i] = 1;count[i] = 1;
            for(int j = 0;j < i;j++)
            {
                if(nums[i] > nums[j])
                    if(dp[j] + 1 == dp[i])  //发现一条新路到当前位置，因此加上之前的路线数，因为初始化为1，故无需继续加1
                        count[i] += count[j];
                    else if(dp[j] + 1 > dp[i]){
                        dp[i] = dp[j] + 1; 
                        count[i] = count[j];//之前认为dp【i】为最长，但之后被推翻，故计数无效，count【j】为之前进行过判断的计数器，因此能确保为j之前阶段最长序列的总数，故直接拿来用就好了
                    }
            }
        }
        //最后统计环节，可加入到上面循环，但是放外面更好看懂，故放在外面了
        int Max = 0;
        for(int i = 0;i < n;i++)
            Max = Max>dp[i]?Max:dp[i];
        int sum = 0;
        for(int i = 0;i < n;i++)
            if(Max == dp[i])
                sum += count[i];
        return 0;
    }
};

俄罗斯套娃信封问题

给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。

当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。

请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。

注意：不允许旋转信封。

示例 1：

输入：envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出：3
解释：最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。

示例 2：

输入：envelopes = [[1,1],[1,1],[1,1]]
输出：1

提示：

    1 <= envelopes.length <= 5000
    envelopes[i].length == 2
    1 <= wi, hi <= 104

c++代码：

class Solution {
public:
    static bool cmp(vector<int> a, vector<int> b){//二维数组sort排序方法，当然这里只适用于这里，可以适当修改一下，作为通用法
        if(a[0] != b[0])return a[0] < b[0];
        return a[1] < b[1]; 
    }
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        int n = envelopes.size();
        vector<int> dp(n);
        
        sort(envelopes.begin(), envelopes.end(), cmp);

        for(int i = 0;i < n;i++){
            dp[i] = 1;
            for(int j = 0;j < i;j++){
                if(envelopes[i][0] > envelopes[j][0] && envelopes[i][1] > envelopes[j][1]){
                    dp[i] = max(dp[j] + 1, dp[i]);
                }
            }
        }
        int Max = 0;
        for(int i = 0;i < n;i++){
            if(Max < dp[i])
                Max = dp[i];
        }
        return Max;
    }
};

最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [0]
输出：0

示例 4：

输入：nums = [-1]
输出：-1

示例 5：

输入：nums = [-100000]
输出：-100000

提示：

1 <= nums.length <= 3 * 104
-105 <= nums[i] <= 105

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n);
        dp[0] = nums[0];
        int Max = dp[0];
        for(int i = 1;i < n;i++){
            dp[i] = max(nums[i], dp[i-1]+nums[i]);
            Max = max(dp[i], Max);
        }
        return Max;
    }
};