力扣分类刷题

一、数组

485. 最大连续1的个数

        给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int count = 0;
        int Max_count = 0;
        for(int i = 0;i<nums.size();i++)
        {
            if(nums[i]==1)
            {
                count++;
            }
            else
            {
                Max_count=max(Max_count,count);
                count=0;
            }
        }
        Max_count = max(Max_count, count);
        return Max_count;
    }
};

495. 提莫攻击

在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。

当提莫攻击艾希，艾希的中毒状态正好持续 duration 秒。

正式地讲，提莫在 t 发起攻击意味着艾希在时间区间 [t, t + duration - 1]（含 t 和 t + duration - 1）处于中毒状态。如果提莫在中毒影响结束 前 再次攻击，中毒状态计时器将会 重置 ，在新的攻击之后，中毒影响将会在 duration 秒后结束。

给你一个 非递减 的整数数组 timeSeries ，其中 timeSeries[i] 表示提莫在 timeSeries[i] 秒时对艾希发起攻击，以及一个表示中毒持续时间的整数 duration 。

返回艾希处于中毒状态的 总 秒数。

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) 
    {
        int total_T = 0;
        int end_time = 0;
        for(int i = 0;i < timeSeries.size();i++)
        {
            if(timeSeries[i] >= end_time)
            {
                total_T += duration;
            }
            else
            {
                total_T += timeSeries[i] + duration - end_time;
            }
            end_time =timeSeries[i] + duration;
        }
    return total_T;
    }
};

414. 第三大的数

给你一个非空数组，返回此数组中 第三大的数 。如果不存在，则返回数组中最大的数。

class Solution {
public:
    int thirdMax(vector<int> &nums) {
        sort(nums.begin(), nums.end(), greater<>());
        auto last = unique(nums.begin(), nums.end()); // 去除重复元素  
        nums.erase(last, nums.end()); // 删除重复元素后的空位  
        int n = nums.size();
        if(n >= 3)
        {
            return nums[2];
        }
        else
        {
            return nums[0];
        }
    }
};

628. 三个数的最大乘积

给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积。

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int Max1 = 0,Max2 = 0,Max3 = 0,Max4 = 0,
            Max_1 = 0,Max_2 = 0,Max_3 = 0,
            Max = 0;
        sort(nums.begin(), nums.end(), greater<>());
        int n=nums.size();
        if(n>=3)
        {
            Max1 = nums[0]*nums[1]*nums[2];
            Max2 = nums[n-1]*nums[n-2]*nums[n-3];
            Max3 = nums[0]*nums[1]*nums[n-1];
            Max4 = nums[0]*nums[n-1]*nums[n-2];
            Max_1 = max(Max1,Max2);
            Max_2 = max(Max3,Max4);
            return max(max(Max1, Max2), max(Max3, Max4));  
        }
        else 
        {
            cerr<<"小于3个数";
        }
    return  Max;
    }
};

645. 错误的集合

集合 s 包含从 1 到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外一个数字的值，导致集合 丢失了一个数字 并且 有一个数字重复 。

给定一个数组 nums 代表了集合 S 发生错误后的结果。

请你找出重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        vector<int> error(2);
        int previous = 0;
        int n = nums.size();
        sort(nums.begin(),nums.end());
        for(int i = 0;i<n;i++)
        {
            int  current = nums[i];
            if(current == previous)
            {
                error[0]=current;
            }
            else if(current - previous > 1)
            {
                error[1] = current - 1;
            }
            previous = current;
        }
        if (nums[n - 1] != n) 
        {
            error[1] = n;
        }
    return error;
    }
};

697. 数组的度

给定一个非空且只包含非负数的整数数组 nums，数组的 度 的定义是指数组里任一元素出现频数的最大值。

你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

448. 找到所有数组中消失的数字

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。

1768.交替合并字符串

给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。返回 合并后的字符串 。

思路：

我们直接按照题目的要求模拟即可。我们使用两个指针 i 和 j，初始时分别指向两个字符串的首个位置。随后的每次循环中，依次进行如下的两步操作：

• 如果 i 没有超出 word1的范围，就将 word1[i] 加入答案，并且将 i 移动一个位置；
• 如果 j 没有超出 word2的范围，就将 word2[j] 加入答案，并且将 j 移动一个位置。
• 当 i 和 j 都超出对应的范围后，结束循环并返回答案即可。

class Solution {
public:
    string mergeAlternately(string word1, string word2) {
        int m = word1.size();
        int n = word2.size();
        int i = 0, j = 0;
        string result;
        result.reserve(m + n);
        while(i < m || j < n)
        {
            if(i < m)
            {
                result.push_back(word1[i]);
                ++i;
            }
            if(j < n)
            {
                result.push_back(word2[j]);
                ++j;
            }
        }
        return result;
    }

};