class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        // 记录最大连续1个数
        int max = 0;
        // 记录数组中存在1个数
        int sum = 0;
        // 遍历连续1个数
        int count = 0;
        for (int i = 0; i < nums.size() - 1; i++) {
            if (nums[i] == 1)
                sum++;
            if (nums[i] == nums[i + 1] && nums[i] == 1)
            {
                count++;
                if (count > max) {
                    max = count;
                }
            }
            else {
                count = 0;
            }
        }
        // 检查数组最后一个元素是否是1
        if (nums[nums.size() - 1] == 1)
        {
            sum++;
        }
        // 起始计数均设为0，若数组中存在1则实际count应多一
        if (sum > 0) {
            max++;
        }
        return max;
    }
};

本人解法非常绕，思路很乱，边界值测试好多遍才通过。学习优解答案！！

答案

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int max = 0;
        int count = 0;
        for (int i = 0; i < nums.size(); i++) {
            // 如果是元素1则计数++
            if (nums[i] == 1)
            {
                count++;
            }
            // 不是1则不连续，对比max和count进行max更新，计数重置为0
            else {
                if (max < count)
                    max = count;
                count = 0;
            }
        }
        // 对比max和count进行max更新
        if (max < count)
            max = count;
        return max;
    }
};
};

summary：主要没有把握题目中仅有0，1两种元素对于连续的操作。

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
        int sum = 0;
        // 先不考虑最后一次攻击
        for (int i = 0; i < timeSeries.size() - 1; i++) {
        	// 攻击+持续时间<下一次攻击时间，则可以在持续时间内均中毒
            if (timeSeries[i] + duration - 1 < timeSeries[i + 1])
            {
                sum += duration;
            }
            // 否则，只能在两次连续攻击中间时间中毒，此时间<持续时间
            else
            {
                sum = sum + timeSeries[i + 1] - timeSeries[i];
            }
        }
        // 最后一次攻击永远可以持续中毒
        return sum + duration;
    }
};

答案

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
        int ans = 0;
        int expired = 0;
        for (int i = 0; i < timeSeries.size(); ++i) {
        	// 未中毒，则可以完成duration中毒
            if (timeSeries[i] >= expired) {
                ans += duration;
            } else {
            	// 正在中毒，减去上次中毒结束时间
                ans += timeSeries[i] + duration - expired;
            }
            // 未中毒起始时间
            expired = timeSeries[i] + duration;
        }
        return ans;
    }
};

class Solution {
public:
    int thirdMax(vector<int>& nums) {
    	// sort排序数组函数
        sort(nums.begin(), nums.end());
        // reverse反转数组函数
        reverse(nums.begin(), nums.end()); 
        // erase去重数组函数
        nums.erase(unique(nums.begin(), nums.end()), nums.end()); 
        if(nums.size()>=3){
            return nums[2];
        }
        else{
            return nums[0];
        }
    }
};

答案

class Solution {
public:
    int thirdMax(vector<int> &nums) {
    	// greater从大到小排序
        sort(nums.begin(), nums.end(), greater<>());
        for (int i = 1, diff = 1; i < nums.size(); ++i) {
            if (nums[i] != nums[i - 1] && ++diff == 3) { // 此时 nums[i] 就是第三大的数
                return nums[i];
            }
        }
        return nums[0];
    }
};

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int len = nums.size();
        // 将数组降序
        sort(nums.begin(), nums.end(), greater<>());
        // 能得到三个数乘积最大值有两种情况：
        // 1.全部为正数数组升序排列后，前三个元素乘积最大
        // 2.既含有正数也含有负数的数组，两个中最大的负数和最大的正数相乘也可能得到最大乘积
        // 3.两种情况比较得出最大值返回
        int result = nums[0] * nums[1] * nums[2];
        int result1 = nums[0] * nums[len - 1] * nums[len - 2];
        if (result < result1) {
            return result1;
        }
        else {
            return result;
        }
    }
};