算法学习day15——刷题(数组)

一、提莫攻击(数组)

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

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

思路：

我在这里每次只考虑本次攻击造成的中毒时间，需要考虑到下一次攻击的时间。

如果在中毒的范围内，下一次攻击发生了，那么本次攻击造成的中毒时间就要重新计算=timeSeries[i+1]-timeSeries[i]

如果不在中毒的范围内，下一次攻击发生了。那么中毒时间+duration

最后需要注意的是：最后一次攻击的中毒duration也要算进去。

代码：

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        int time=0;
        for(int i=0;i<timeSeries.length;i++){
            //下一次攻击的时候，不处于中毒状态 直接加
            if(i<timeSeries.length-1&&timeSeries[i]+duration-1<timeSeries[i+1]){
                time+=duration;
            //下一次攻击的时候，处于中毒状态，更新duration
            }else if(i<timeSeries.length-1&&timeSeries[i]+duration-1>=timeSeries[i+1]){
                time=time+timeSeries[i+1]-timeSeries[i];
            }
        }
        return time+duration;
    }
}

二、第三大的数(一次遍历)

使用a、b、c分别代表第一大、第二大、第三大。

在遍历数组的同时，判断是否比a\b\c大然后更新a\b\c

if(num>a)c=b;b=a;a=i; if(a>num&&num>b)c=b;b=i; if(b>num&&num>c)c=num;

代码：

class Solution {
    public int thirdMax(int[] nums) {
        long a = Long.MIN_VALUE, b = Long.MIN_VALUE, c = Long.MIN_VALUE;
        for (long i : nums) {
            if (i > a) {
                c = b;
                b = a;
                a = i;
            } else if (i < a && i > b) {
                c = b;
                b = i;
            } else if (i < b && i > c) {
                c = i;
            }
        }
        return c == Long.MIN_VALUE ? (int) a : (int) c;
    }
}

注意：定义变量的时候，数据类型是long不是Long。

三、三个数的最大乘积

分析：

如果三个数都是正数，那么就返回nums[size]*nums[size-1]*nums[size-2]

如果三个数都是负数，那么也返回nums[size]*nums[size-1]*nums[size-2]

如果有正有负，最大值会在三正/两负一正中出现,即Math.max(nums[size]*nums[size-1]*nums[size-2],nums[0]*nums[1]*nums[size]);

综上所述，返回的结果为Math.max(nums[size]*nums[size-1]*nums[size-2],nums[0]*nums[1]*nums[size]);

代码：

class Solution {
    public int maximumProduct(int[] nums) {
        int size=nums.length-1;
        int result=0;
        Arrays.sort(nums);//排序
        result=Math.max(nums[size]*nums[size-1]*nums[size-2],nums[0]*nums[1]*nums[size]);
        return result;
    }
}

四、数组的度

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

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

注意：可能存在两个数的频率相同,因此要求一个最短的连续子数组

思路:

将数组中最大频率和每一个元素的频率求出来。以及他们的startIndex和endIndex。

然后一次for循环遍历求minLength;

代码:

class Solution {
    public int findShortestSubArray(int[] nums) {
        HashMap<Integer,Integer> countMap=new HashMap<>();
        HashMap<Integer,Integer> firstIndexMap=new HashMap<>();
        HashMap<Integer,Integer> endIndexMap=new HashMap<>();
        int maxCount=0;
        //遍历数组 记录每一个值的count、firstIndex、endIndex
        for(int i=0;i<nums.length;i++){
            countMap.put(nums[i],countMap.getOrDefault(nums[i],0)+1);
            if(!firstIndexMap.containsKey(nums[i])){
                firstIndexMap.put(nums[i],i);
            }
            endIndexMap.put(nums[i],i);
            maxCount=Math.max(maxCount,countMap.get(nums[i]));
        }
        //遍历数组 求最小长度
        int minLength=nums.length;
        for(int i=0;i<nums.length;i++){
            if(maxCount==countMap.get(nums[i])){
                int endIndex=endIndexMap.get(nums[i]);
                int startIndex=firstIndexMap.get(nums[i]);
                minLength=Math.min(minLength,endIndex-startIndex+1);
            }
        }
        return minLength;
    }
}

五、缺失的第一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案

注意：

要求时间复杂度为O(n)，并且空间复杂度只可以为常数级别(意味着不能开辟其他空间给数组或者xxx)；

思路：

让每一个正整数都回到自己的位置上。eg:1回到nums[0],2回到nums[1]....。然后遍历数组，如果出现了nums[i]!=i+1的。就是缺失的第一个正数。

如何让每一个正整数回到自己的位置上。swap(nums[i],nums[nums[i]-1]);如果nums[i]是4，就要回到下标为4的位置上，nums[4]=5;

为什么是while呢？下面的nums中，如果是if的话：3和-1互换位置，然后4和1互换位置。此时已经遍历到第三个元素了，1仍然在index=1的位置上，无法遍历到。所以返回的结果即缺失的第一个正数是1，但是1是存在的。

因此要加上while，4和1调换位置之后，继续换1。

代码:

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;
        for(int i=0;i<n;i++){
            while(nums[i]>0&&nums[i]<=n&&nums[nums[i]-1]!=nums[i]){
                int temp=nums[nums[i]-1];
                nums[nums[i]-1]=nums[i];
                nums[i]=temp;
            }
        }
        for(int i=0;i<n;i++){
            if(nums[i]!=i+1)return i+1;
        }
        return n+1;
    }
}

六、H指数(题目难以理解)

根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数 是指他（她）至少发表了 h 篇论文，并且 至少 有 h 篇论文被引用次数大于等于 h 。如果 h 有多种可能的值，h 指数 是其中最大的那个

思路：

将数组进行升序排列，遍历到i的时候至少有(size-i)篇论文被引用。被引用的次数就是citations[i]

，如果citations[i]>=size-i,那么就是一个h指数。每次循环都要对h指数进行一个Math.max。

代码：

class Solution {
    public int hIndex(int[] citations) {
        Arrays.sort(citations);
        int size = citations.length;
        int hIndex = 0; // 初始 H 指数为 0

        for (int i = 0; i < size; i++) {
            int h = size - i; // 当前可能的 H 指数
            if (citations[i] >= h) {
                hIndex = Math.max(hIndex,h); // 更新 H 指数
            }
        }
        return hIndex;
    }
}

七、最小操作次数使数组元素相等(思维题）

八、非递减数列

给你一个长度为 n 的整数数组 nums ，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。

当遇到nums[i-1]>nums[i]的时候，就说明出现递减的情况。但是有的元素排列在经过一次操作后不能变成一个非递减数列，有的元素经过一次操作后可以变成。

一共有三种情况：

当遇到eg:4 2 3的情况的时候，i==1&&nums[i]<nums[i-1]意味着nums[i-2]不存在，那么只能改变nums[i-1]。

如果遇到:2 5 3 4的情况,  i>1 nums[i]<nums[i-1]&&nums[i]>nums[i-2],那么就要改变nums[i-1]

如果遇到:4 5 3 4 的情况, i>1  nums[i]<nums[i-1]&&nums[i]<nums[i-2],那么只能改变nums[i]。

所以：在前提条件nums[i]<nums[i-1]的情况之下，又细分三种情况。

代码：

class Solution {
    public boolean checkPossibility(int[] nums) {
        int count=0;
        for(int i=1;i<nums.length;i++){
            //如果出现这种情况就不是非递减序列
            if(nums[i-1]>nums[i]){
                if(i==1){
                    nums[i-1]=nums[i];
                }else if(i>1&&nums[i-2]<=nums[i]){
                    nums[i-1]=nums[i];
                }else if(i>1&&nums[i-2]>nums[i]){
                    nums[i]=nums[i-1];
                }
                count++;
            }
        }
        return count<=1;
    }
}