LeetCode题解 Day1数组的遍历

题目编号：485、495、414、628

485 最大连续1的个数

思路：刚开始的想法是计算当前连续1的个数，然后更新最大连续1的个数，具体的实现，就是在当前数组值为1时，计数且更新最大个数，如果当前数组值为0，将当前连续1个数置0，继续循环。
代码如下：

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

题解思路：使用滑动窗口，遍历数组，保存遇到的最后一个0的位置Index,
当前i位置为0，则更新Index值；当前i位置为1，则连续1个数为i-Index。
代码如下：

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

总体上，思路差异不大。

495 提莫攻击

思路：参数有提莫的攻击时间序列和中毒持续时间，以[1,2],2,为例，第1s初攻击，持续到第2s末，而第二次攻击在第2s初，中毒状态不可叠加，所以第2s初的攻击在第3s末结束，最终结果为3s.分析当前的攻击时间加上持续时间如果大于下次攻击时间，说明本次中毒持续时间尚未结束就受到了下一次攻击，也就是说本次的中毒被覆盖了，可以不考虑本次，按下次的开始时间考虑，则本次持续时间为下次攻击时间-本次攻击时间；如果小于下次攻击时间，则本次持续时间为给定的中毒持续时间。需要注意的是如果没有攻击，则总持续时间为0.
代码如下：

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
        int n=timeSeries.size();
        int L,R,T=0;
        if(n)
        {
            for(int i=0;i<n-1;i++){
                L=timeSeries[i];
                R=L+duration;
                if(R>timeSeries[i+1])
                    R=timeSeries[i+1];
                T+=R-L;
            }
            T+=duration;
        }
         return T;
    }
};

时间复杂度：O(N)
空间复杂度：O(1)

可以优化的地方：可以直接比较timeSeries[i+1]-timeSeries[i]和duration的大小，小的为实际持续时间。且要记得加上最后一次攻击的持续时间。

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
        int n=timeSeries.size();
        int L,R,T=0;
        if(n)
        {
            for(int i=0;i<n-1;i++)
               T+=min(timeSeries[i+1]-timeSeries[i],duration);
            T+=duration;
        }
         return T;
    }
};

414 第三大的数

思路：一种是对数组排序找到第三大的数；另一种是依次找到第一、第二、第三大的数。根据题目的要求，第三大的数是唯一出现的。具体实现是先找到最大的数，然后从其他数中再找到下一个最大的数，再继续找到下一个最大的数。需要考虑的是不存在第三大的数的情况，因此添加了标志位，检查是否进行了第三次筛选。
问题：要注意最大值的初始值，给定为一个最小的值，以确保存在最大值的情况下会发生更新。
代码如下：

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        int Min=-2147483648;
        int Max=Min,firstMax=Min;
        int secondMax=Min,thMax=Min;
        int n=nums.size();
        int flag=0;
        for(int i=0;i<n;i++)
            Max=max(Max,nums[i]);
        firstMax=Max;
        Max=Min;
        for(int i=0;i<n;i++){
            if(nums[i]!=firstMax)
                Max=max(Max,nums[i]);
        }
        secondMax=Max;
        Max=Min;
        for(int i=0;i<n;i++){
            if(nums[i]!=firstMax&&nums[i]!=secondMax)
            {
                Max=max(Max,nums[i]);
                flag=1;
            }
        }
        thMax=Max;
        if(flag)
            return thMax;
        else return firstMax;
    }
};

可以借鉴的方法：用三个变量来存放第一、第二、第三大的值，分别为one,two,three。遍历数组，若比one大，则更新one,two为原先的one,three为原先的two，同理比two大和比three大。需要注意的是怎样确定three的值是否发生更新。最简单的方法是给three一个数组中不可能取到的初始值，最后值未变的话，则返回最大值。

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        long Min=LONG_MIN;
        long one=nums[0],two=Min,three=Min;
        int n=nums.size();
        for(int i=1;i<n;i++){
            if(nums[i]==one||nums[i]==two||nums[i]==three) continue;
            if(nums[i]>one){
                three=two;
                two=one;
                one=nums[i];
            }else if(nums[i]>two){
                three=two;
                two=nums[i];
            }else if(nums[i]>three)
            {
                three=nums[i];
            }
        }
        if(three==Min)
            return one;
        else return three;
    }
};

628 三个数的最大乘积

思路：分析数组可能的情况。全为正数，则最大值为三个最大的数的积；全为负数，最大值也是三个最大的数（绝对值最小）的积；有正有负，则可能是三个最大的正数，或是两个最小的负数*一个最大的正数。因此只需要找到三个最大的数，和两个最小的数，比较即可得到最大积。实现方法和上一题类似。
代码如下：

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int Min=INT_MIN,Max=INT_MAX;
        int onez=Min,twoz=Min,threez=Min;
        int onef=Max,twof=Max;
        int n=nums.size();
        for(int i=0;i<n;i++){
            if(nums[i]>=onez){
                threez=twoz;
                twoz=onez;
                onez=nums[i];
            }else if(nums[i]>=twoz){
                threez=twoz;
                twoz=nums[i];
            }else if(nums[i]>=threez){
                threez=nums[i];
            }
            if(nums[i]<=onef){
                twof=onef;
                onef=nums[i];
            }else if(nums[i]<=twof){
                twof=nums[i];
            }
        }
        return max(onez*twoz*threez,onef*twof*onez);
    }
};

时间复杂度：O（N）
空间复杂度：O（1）
另一种思路：先排序，在比较可能是最大积的几种情况。但涉及到排序，时间复杂度为O（NlogN)。