目录
一、题目一
1、题目描述
给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的 最大差值 ，其中 0 <= i < j < n 且 nums[i] < nums[j] 。
返回 最大差值 。如果不存在满足要求的 i 和 j ，返回 -1 。
示例 1：
输入：nums = [7,1,5,4]
输出：4
解释：
最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4 。
注意，尽管 i = 1 且 j = 0 时 ，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。
示例 2：
输入：nums = [9,4,3,2]
输出：-1
解释：
不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。
示例3：
输入：nums = [1,5,2,10]
输出：9
解释：
最大差值出现在 i = 0 且 j = 3 时，nums[j] - nums[i] = 10 - 1 = 9 。
2、基础框架
Java 版本给出的基础框架代码如下：
class Solution {
public int maximumDifference(int[] nums) {
}提示：
n == nums.length2 <= n <= 10001 <= nums[i] <= 109
3、原题链接
LeetCode 2016. 增量元素之间的最大差值
二、题目一解题报告
1、思路分析
见代码详解注释
2、代码详解
class Solution {
public int maximumDifference(int[] nums) {
int n=nums.length;
int min=0;
//两层遍历更新min的值
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
//后面的和前面相减保证满足i<j
int t=nums[j]-nums[i];
//t>0保证nums[j]>nums[i]
if(min<t&&t>0){
min=nums[j]-nums[i];
}
}
}
//如果遍历完min的值还为0则没找到符合条件的返回-1
return min==0?-1:min;
}
}二、题目二
1、题目描述
给你一个长度为
n的整数数组nums，请你返回nums中最 接近0的数字。如果有多个答案，请你返回它们中的 最大值 。
示例 1：
输入：nums = [-4,-2,1,4,8]
输出：1
解释：
-4 到 0 的距离为 |-4| = 4 。
-2 到 0 的距离为 |-2| = 2 。
1 到 0 的距离为 |1| = 1 。
4 到 0 的距离为 |4| = 4 。
8 到 0 的距离为 |8| = 8 。
所以，数组中距离 0 最近的数字为 1 。
示例 2：
输入：nums = [2,-1,1] 输出：1 解释：1 和 -1 都是距离 0 最近的数字，所以返回较大值 1 。
示例3：
输入：nums = [1,5,2,10]
输出：9
解释：
最大差值出现在 i = 0 且 j = 3 时，nums[j] - nums[i] = 10 - 1 = 9 。
2、基础框架
Java 版本给出的基础框架代码如下：
class Solution {
public int findClosestNumber(int[] nums) {
}提示：
n == nums.length2 <= n <= 10001 <= nums[i] <= 109
3、原题链接
LeetCode 2239. 找到最接近 0 的数字
二、题目二解题报告
1、思路分析
见代码详解注释
2、代码详解
class Solution {
public int findClosestNumber(int[] nums) {
//用来更新绝对值
int maxRes=100000;
//用来放符合的原值
int res=0;
int n=nums.length;
//遍历
for(int i=0;i<n;i++){
if(Math.abs(nums[i])<=maxRes){
//更新绝对值最小的
maxRes=Math.abs(nums[i]);
//储存原值
res=nums[i];
}
}
//再次遍历查找有没有正的元素和res相等，有着更新res
for(int i=0;i<n;i++){
if(Math.abs(res)==nums[i]){
res=nums[i];
}
}
return res;
}
}
三、题目三
1、题目描述
给你一个数组 prices ，其中 prices[i] 是商店里第 i 件商品的价格。
商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的 最小下标 ，如果没有满足条件的 j ，你将没有任何折扣。
请你返回一个数组，数组中第 i 个元素是折扣后你购买商品 i 最终需要支付的价格。
示例 1：
输入：prices = [8,4,6,2,3]
输出：[4,2,4,2,3]
解释：
商品 0 的价格为 price[0]=8 ，你将得到 prices[1]=4 的折扣，所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ，你将得到 prices[3]=2 的折扣，所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。
示例 2：
输入：prices = [1,2,3,4,5] 输出：[1,2,3,4,5] 解释：在这个例子中，所有商品都没有折扣。
示例3：
输入：prices = [10,1,1,6] 输出：[9,0,1,6]
2、基础框架
Java 版本给出的基础框架代码如下：
class Solution {
public int[] finalPrices(int[] prices) {
}提示：
1 <= prices.length <= 5001 <= prices[i] <= 10^3
3、原题链接
LeetCode 1475. 商品折扣后的最终价格
二、题目三解题报告
1、思路分析
看题半小时，解题三分钟系列
题目的意思就是在prices[i]后面找到第一个比他小的prices[j]
- 找到则打折即 ：prices[i]=prices[i]-prices[j];
- 找不到则不打折即原值返回
2、代码详解
class Solution {
public int[] finalPrices(int[] prices) {
int n = prices.length;
int[] res=new int[n];
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(prices[i]>=prices[j]){
res[i]=prices[i]-prices[j];
break;
}else{
res[i]=prices[i];
}
}
}
res[n-1]=prices[n-1];
return res;
}
}四、题目四
1、题目描述
给你一个二维整数数组 nums ，其中 nums[i] 是由 不同 正整数组成的一个非空数组，按 升序排列 返回一个数组，数组中的每个元素在 nums 所有数组 中都出现过。
示例 1：
输入：nums = [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]]
输出：[3,4]
解释：
nums[0] = [3,1,2,4,5]，nums[1] = [1,2,3,4]，nums[2] = [3,4,5,6]，在 nums 中每个数组中都出现的数字是 3 和 4 ，所以返回 [3,4] 。
示例 2：
输入：nums = [[1,2,3],[4,5,6]]
输出：[]
解释：
不存在同时出现在 nums[0] 和 nums[1] 的整数，所以返回一个空列表 [] 。
2、基础框架
Java 版本给出的基础框架代码如下：
class Solution {
public List<Integer> intersection(int[][] nums) {
}提示：
- 1 <= nums.length <= 1000
- 1 <= sum(nums[i].length) <= 1000
- 1 <= nums[i][j] <= 1000
- nums[i] 中的所有值 互不相同
3、原题链接
LeetCode 2248. 多个数组求交集
二、题目四解题报告
1、思路分析
nums[i] 是由 不同 正整数组成的一个非空数组因此
记录每个元素出现的次数，出现次数等于行数即为交集元素
2、代码详解
class Solution {
public List<Integer> intersection(int[][] nums) {
int n = nums.length;
int m = nums[0].length;
Map<Integer, Integer> map = new TreeMap<>();
List<Integer> list = new ArrayList<>();
//遍历并记录元素出现的次数
for (int[] anInt : nums) {
for (int i : anInt) {
if(map.containsKey(i)){
Integer integer = map.get(i);
map.put(i,++integer);
}else{
map.put(i,1);
}
}
}
//判断若元素出现的次数等于行数，则把其加入到集合中
Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
for (Map.Entry<Integer, Integer> entry : entries) {
Integer value = entry.getValue();
if(value==n){
list.add(entry.getKey());
}
}
return list;
}
}