力扣热题100——数组

最大子数组和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;
        int pre = nums[0]; // 保存以当前元素前一个元素结尾的最大子数组和
        int maxSum = pre;
        for (int i = 1; i < n; ++i) {
            pre = max(pre + nums[i], nums[i]);
            maxSum = max(maxSum, pre);
        }
        return maxSum;
    }
};

合并区间

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> res;
        sort(intervals.begin(),intervals.end());
        for(int i=0;i<intervals.size();){
            int last=intervals[i][1];
            int j=i+1;
            while(j<intervals.size()&&intervals[j][0]<=last){
                last=max(last,intervals[j][1]);
                j++;
            }
            res.push_back({intervals[i][0],last});
            i=j;
        }
        return res;
    }
};

轮转数组

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n=nums.size();
        k%=n;
        reverse(nums.begin(),nums.end());
        reverse(nums.begin(),nums.begin()+k);
        reverse(nums.begin()+k,nums.end());
    }
};

除自身以外数组的乘积

#include <vector>
using namespace std;

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> result(n, 1);  // 替换错误的数组定义，使用vector
        //result[1,1,1,1]
        // 计算前缀积：result[i] 存储 nums[0..i-1] 的乘积
        for (int i = 1; i < n; ++i) {
            result[i] = result[i - 1] * nums[i - 1];
        }
        
        // 计算后缀积并与前缀积相乘，得到最终结果
        int suffix = 1;  // 用于存储后缀积
        for (int i = n - 1; i >= 0; --i) {
            result[i] *= suffix;  // 前缀积 × 后缀积
            suffix *= nums[i];    // 更新后缀积
        }
        
        return result;
    }
};

第一个循环的作用是：计算当前元素左侧所有元素的乘积

  for (int i = 1; i < n; ++i) {
            result[i] = result[i - 1] * nums[i - 1];
        }

假设输入为【2，3，4，5】
当 i=1 时：
result[1] = result[0] * nums[0] = 1 * 2 = 2
此时 result = [1, 2, 1, 1]
（表示索引 1 左侧只有元素 2）
当 i=2 时：
result[2] = result[1] * nums[1] = 2 * 3 = 6
此时 result = [1, 2, 6, 1]
（表示索引 2 左侧元素是 2 和 3，乘积为 6）
当 i=3 时：
result[3] = result[2] * nums[2] = 6 * 4 = 24
此时 result = [1, 2, 6, 24]
（表示索引 3 左侧元素是 2、3、4，乘积为 24）
第二个循环：计算后缀积并合并结果（从右到左）

int suffix = 1;  // 用于存储后缀积
        for (int i = n - 1; i >= 0; --i) {
            result[i] *= suffix;  // 前缀积 × 后缀积
            suffix *= nums[i];    // 更新后缀积
        }

当 i=3 时：
第一步：result[3] *= suffix → 24 * 1 = 24
（索引 3 右侧没有元素，后缀积为 1）
第二步：suffix *= nums[3] → 1 * 5 = 5
此时 result = [1, 2, 6, 24]，suffix = 5
当 i=2 时：
第一步：result[2] *= suffix → 6 * 5 = 30
（索引 2 右侧元素是 5，乘积为 5）
第二步：suffix *= nums[2] → 5 * 4 = 20
此时 result = [1, 2, 30, 24]，suffix = 20
当 i=1 时：
第一步：result[1] *= suffix → 2 * 20 = 40
（索引 1 右侧元素是 4、5，乘积为 20）
第二步：suffix *= nums[1] → 20 * 3 = 60
此时 result = [1, 40, 30, 24]，suffix = 60
当 i=0 时：
第一步：result[0] *= suffix → 1 * 60 = 60
（索引 0 右侧元素是 3、4、5，乘积为 60）
第二步：suffix *= nums[0] → 60 * 2 = 120
最终 result = [60, 40, 30, 24]

缺失的第一个证书

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        unordered_set<int> numset;

        for(int num:nums){
            if(num>0)
                numset.insert(num);
        }

        int i=1;
        while(true){
            if(numset.find(i)==numset.end()){
                return i;
            }
            i++;
            }       
        }
};