力扣---数组

最新推荐文章于 2022-09-06 11:14:20 发布

Sunshing15

最新推荐文章于 2022-09-06 11:14:20 发布

阅读量259

点赞数

分类专栏：力扣文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_52721512/article/details/125077936

版权

力扣专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

题目
解题思路与代码详情
参考文献

题目

解题思路与代码详情

【题1】2016. 增量元素之间的最大差值

2016. 增量元素之间的最大差值： 给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的最大差值，其中 0 <= i < j < n 且 nums[i] < nums[j] , 返回最大差值。
如果不存在满足要求的 i 和 j ，返回 -1 。

题目解析： 题目要求 $n u m s [j] - n u m s [i]$ , $0 < = i < j < n$ ， $n u m s [i] < n u m s [j]$ ，即所求结果为后项减前项的差，且需要后项的数值大于前项，若所有后项数值都不大于前项，则结果返回 -1。
解题思路：

暴力枚举：遍历数组中元素，确定数组中元素相减的差，同时针对数组中元素的前后项大小关系的情况，设置指标性变量，一旦 $n u m s [i] < n u m s [j]$ 的情况出现，即求返回结果，同时指标性变量发生变化。

# python3
class Solution:
    def maximumDifference(self, nums: List[int]) -> int:
        n = len(nums)
        ans = -max(nums)
        flag = 0
        for i in range(n):
            for j in range(i+1, n):
                if nums[i]<nums[j]:
                    flag = 1
                ans = max(ans, nums[j]-nums[i])
        if flag==0:
            ans = -1
        return ans

//C
int maximumDifference(int* nums, int numsSize){
    int ans = -1000;
    int flag = 0;
    for(int i=0;i<numsSize;i++){
        for(int j=i+1; j<numsSize; j++){
            if(nums[i] < nums[j]){
                flag = 1;
            }
            ans = fmax(ans, nums[j]-nums[i]);
        }
    }
    if (flag == 0){
        ans = -1;
    }
    return ans;
}

前缀最小值（官方解答版）
解题思路： 求后项减去前项的最大值，那么需要在数组的前一部分找一个最小值，后一部分找一个最大值，所以可以设定一个变量premin用于存储前半部分的最小值，先固定这个premin值，然后逐一遍历数组元素，一旦存在nums[i]大于当前固定的premin值，就执行返回结果的操作，否则更新以nums[i]的值来更新premin的取值。同时考虑到数组可能会存在所有后项元素都不大于前项元素的情况，先设定返回值为-1。

#python 3
class Solution:
    def maximumDifference(self, nums: List[int]) -> int:
        n = len(nums)
        ans = -1
        premin = nums[0]
        for i in range(n):
            if nums[i]>premin:
                ans = max(ans, nums[i]-premin)
            else:
                premin = nums[i]
        return ans

//C
int maximumDifference(int* nums, int numsSize){
    int premin = nums[0];
    int ans = -1;
    for(int i=0; i<numsSize; i++){
        if(nums[i]>premin){
            ans = fmax(ans, nums[i]-premin);
        }else{
            premin = nums[i];
        }
    }
    return ans;
}

【题2】2239. 找到最接近 0 的数字

2239. 找到最接近 0 的数字： 给你一个长度为 n 的整数数组 nums ，请你返回 nums 中最接近 0 的数字。如果有多个答案，请你返回它们中的最大值。

#python3
class Solution:
    def findClosestNumber(self, nums: List[int]) -> int:
        n = len(nums)
        ans = nums[0]
        for i in range(1,n):
            if abs(nums[i])<abs(ans):
                ans = nums[i]
            if abs(nums[i])==abs(ans):
                ans = max(ans, nums[i])
        return ans

//C
int findClosestNumber(int* nums, int numsSize){
    int ans = nums[0];
    for(int i=1;i<numsSize;i++){
        if(abs(nums[i]) < abs(ans)){
            ans = nums[i]; 
        }
        if(abs(nums[i]==abs(ans))){
            ans = fmax(ans, nums[i]);
        }
    }
    return ans;
}

【题3】1475. 商品折扣后的最终价格

1475. 商品折扣后的最终价格： 给你一个数组 prices ，其中 prices[i] 是商店里第 i 件商品的价格。

商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的最小下标，如果没有满足条件的 j ，你将没有任何折扣。

请你返回一个数组，数组中第 i 个元素是折扣后你购买商品 i 最终需要支付的价格。

#python3
class Solution:
    def finalPrices(self, prices: List[int]) -> List[int]:
        n = len(prices)
        ret = [0]*n
        for i in range(n-1):
            temp=0
            for j in range(n-1,i,-1):
                if prices[j] <= prices[i]:
                    temp = j
            if temp==0:
                ret[i]=prices[i]
            else:
                ret[i]=prices[i]-prices[temp]
        ret[n-1]=prices[n-1]
        return ret

//C
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* finalPrices(int* prices, int pricesSize, int* returnSize){
    int *ret = (int *)malloc(sizeof(int)*pricesSize);
    *returnSize = pricesSize;
    for(int i =0;i<pricesSize-1;i++){
        int temp=0;
        for(int j=pricesSize-1;j>i;j--){
            if(prices[j] <= prices[i]){
                temp=j;
            }
            if(temp==0){
            ret[i]=prices[i];
            }
            else{
                ret[i]=prices[i]-prices[temp];
            }  
        } 
    }
    ret[pricesSize-1]=prices[pricesSize-1];
    return ret;
    free(ret);
}

【题4】2248. 多个数组求交集

2248. 多个数组求交集： 给你一个二维整数数组 nums ，其中 nums[i] 是由不同正整数组成的一个非空数组，按 升序排列 返回一个数组，数组中的每个元素在 nums 所有数组 中都出现过。

class Solution:
    def intersection(self, nums: List[List[int]]) -> List[int]:
        n = len(nums)
        s=set(nums[0])
        for i in range(1,n):
            s = s.intersection(nums[i])
        ret = list(s)
        ret.sort()
        return ret

【题5】1588. 所有奇数长度子数组的和

1588. 所有奇数长度子数组的和： 给你一个正整数数组 arr ，请你计算所有可能的奇数长度子数组的和。

子数组 定义为原数组中的一个连续子序列。

请你返回 arr 中 所有奇数长度子数组的和 。

class Solution:
    def sumOddLengthSubarrays(self, arr: List[int]) -> int:
        n = len(arr)
        sums = 0
        for i in range(n):
            for j in range(i,n):
                if (j-i+1)%2==1:
                    sums = sums+sum(arr[i:j+1])
        return sums

【题6】1848. 到目标元素的最小距离

1848. 到目标元素的最小距离： 给你一个整数数组 nums （下标 从 0 开始 计数）以及两个整数 target 和 start ，请你找出一个下标 i ，满足 nums[i] == target 且 abs(i - start) 最小化 。注意：abs(x) 表示 x 的绝对值。

返回 abs(i - start) 。

题目数据保证 target 存在于 nums 中。

class Solution:
    def getMinDistance(self, nums: List[int], target: int, start: int) -> int:
        minret = 10000
        n = len(nums)
        for i in range(n):
            if nums[i]==target:
                minret = min(minret,abs(i-start)) 
        return minret

【题7】1652. 拆炸弹

1652. 拆炸弹： 你有一个炸弹需要拆除，时间紧迫！你的情报员会给你一个长度为 n 的循环数组 code 以及一个密钥 k 。

为了获得正确的密码，你需要替换掉每一个数字。所有数字会同时被替换。

如果 k > 0 ，将第 i 个数字用接下来 k 个数字之和替换。
如果 k < 0 ，将第 i 个数字用之前 k 个数字之和替换。
如果 k == 0 ，将第 i 个数字用 0 替换。

由于 code 是循环的， code[n-1] 下一个元素是 code[0] ，且 code[0] 前一个元素是 code[n-1] 。

给你循环数组 code 和整数密钥 k ，请你返回解密后的结果来拆除炸弹！

class Solution:
    def decrypt(self, code: List[int], k: int) -> List[int]:
        n = len(code)
        ret = [0]*n
        for i in range(n):
            if k==0:
                ret[i]=0
            else:
                for j in range(1,abs(k)+1):
                    if k>0:
                        ret[i]=ret[i]+code[(i+j)%n]
                    else:
                        ret[i]=ret[i]+code[(i-j)%n]
        return ret

【题8】1640. 能否连接形成数组

1640. 能否连接形成数组： 给你一个整数数组 arr ，数组中的每个整数 互不相同 。另有一个由整数数组构成的数组 pieces，其中的整数也 互不相同 。请你以 任意顺序 连接 pieces 中的数组以形成 arr 。但是，不允许对每个数组 pieces[i] 中的整数重新排序。

如果可以连接 pieces 中的数组形成 arr ，返回 true ；否则，返回 false 。

class Solution:
    def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
        narr = len(arr)
        mpieces = len(pieces)
        flag = True
        for i in range(mpieces):#遍历pieces数组的子数组
            tempn = len(pieces[i])#计算子数组的长度
            tempj=0
            for j in range(narr):
                if pieces[i][0]==arr[j]:
                    tempj = j
                continue
            if tempj+tempn<=narr:
                for k in range(tempn):
                    if pieces[i][k]==arr[tempj+k]:
                        flag = True
                    else:
                        flag = False
            else:
                flag =False
            if flag == False:
                break
        return flag