一、提莫攻击(数组)
给你一个 非递减 的整数数组 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;
}
}