第358场周赛
1. 数组中的最大数对和
题目描述：
给你一个下标从 0 开始的整数数组 nums 。请你从 nums 中找出和 最大 的一对数，且这两个数数位上最大的数字相等。
返回最大和，如果不存在满足题意的数字对，返回 -1。
示例 1：
输入： nums = [51,71,17,24,42]
输出：88
解释： i = 1 和 j = 2 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 71 + 17 = 88 。 i = 3 和 j = 4 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 24 + 42 = 66 。 可以证明不存在其他数对满足数位上最大的数字相等，所以答案是 88 。
示例 2：
输入： nums = [1,2,3,4]
输出：-1
解释：不存在数对满足数位上最大的数字相等。
提示：
2 <= nums.length <= 1001 <= nums[i] <= 104
解题思路：
- 使用双重for循环遍历数组中的元素
- 如果两数的数位最大值相同则，使用result变量记录当前两数和的最大值nums[i] + nums[j]
代码实现：
class Solution {
public int maxSum(int[] nums) {
// 双指针
int result = -1;
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
int sum = nums[i] + nums[j];
if (sum > result && check(nums[i], nums[j])) {
result = sum;
}
}
}
return result;
}
/**
* 判断两数之和的最大值是否相同
*/
private boolean check(int num1, int num2) {
// 找最大数字
return getMaxNum(num1) == getMaxNum(num2);
}
/**
* 获取当前数的最大值
*/
private int getMaxNum(int num) {
int result = 0;
while (num != 0) {
result = Math.max(result, num % 10);
num /= 10;
}
return result;
}
}
2. 翻倍以链表形式表示的数字
题目描述：
给你一个 非空 链表的头节点 head ，表示一个不含前导零的非负数整数。
将链表 翻倍 后，返回头节点head。
示例 1：
输入：head = [1,8,9]
输出：[3,7,8]
解释：上图中给出的链表，表示数字 189 。返回的链表表示数字 189 * 2 = 378 。
示例 2：
输入：head = [9,9,9]
输出：[1,9,9,8]
解释：上图中给出的链表，表示数字 999 。返回的链表表示数字 999 * 2 = 1998 。
提示：
- 链表中节点的数目在范围
[1, 104]内 0 <= Node.val <= 9- 生成的输入满足：链表表示一个不含前导零的数字，除了数字 0 本身。
解题思路：
- 先将链表遍历一次，使用ArrayList存储每个节点值，同时定义int类型变量flag判断当前节点值是否需要进位以及进位值为多少
- 逆序遍历存储链表节点值的List，将每一个节点值都进行乘2操作并与flag节点值相加计算翻倍后并且增加了进位的值sum
- 判断此时sum值
sum >= 10，更新flag的值为sum / 10，此时将sum - flag * 10值添加到ArrayList中sum < 10，说明没有需要进位的操作，将sum添加到ArrayList中，并将flag进位值赋值为0，防止对后续节点值的计算产生影响
- 结束遍历后再次判断flag的值，判断最后一个节点值是否有进位操作，如果flag不为0则在ArrayList后再添加1
- 逆序遍历ArrayList，根据每一个值来构建链表节点。因为此时存储进位后节点值的ArrayList中的值都是倒序的，例如：[9,9,9]中，在经过步骤1,2,3后，得到的List为[8,9,9,1]
- 返回链表
代码实现：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode doubleIt(ListNode head) {
// 存储链表节点值
List<Integer> nodes = new ArrayList<>();
while (head != null) {
nodes.add(head.val);
head = head.next;
}
// 进位值，初值为0
int flag = 0;
// 存储节点值进行翻倍处理后的值
List<Integer> list = new ArrayList<>();
// 逆序遍历节点值
for (int i = nodes.size() - 1; i >= 0; i--) {
// 计算当前节点值
int sum = nodes.get(i) * 2 + flag;
if (sum >= 10) {
// 更新进位值
flag = sum / 10;
// 添加节点值
list.add(sum - flag * 10);
} else {
// 更新进位值
flag = 0;
list.add(sum);
}
}
// 判断最后一个元素是否有进位操作
if (flag != 0) {
list.add(1);
}
// 构造新链表
ListNode result = new ListNode(0), temp = result;
// 逆序遍历存储节点值
for (int i = list.size() - 1; i >= 0; i--) {
// 添加链表节点
ListNode node = new ListNode(list.get(i));
temp.next = node;
temp = temp.next;
}
return result.next;
}
}
3. 限制条件下元素之间的最小绝对差
题目描述：
给你一个下标从 0 开始的整数数组 nums 和一个整数 x 。
请你找到数组中下标距离至少为 x 的两个元素的 差值绝对值 的 最小值 。
换言之，请你找到两个下标 i 和 j ，满足 abs(i - j) >= x 且 abs(nums[i] - nums[j]) 的值最小。
请你返回一个整数，表示下标距离至少为 x 的两个元素之间的差值绝对值的 最小值 。
示例 1：
输入：nums = [4,3,2,4], x = 2
输出：0
解释：我们选择 nums[0] = 4 和 nums[3] = 4 。 它们下标距离满足至少为 2 ，差值绝对值为最小值 0 。 0 是最优解。
示例 2：
输入：nums = [5,3,2,10,15], x = 1
输出：1
解释：我们选择 nums[1] = 3 和 nums[2] = 2 。 它们下标距离满足至少为 1 ，差值绝对值为最小值 1 。 1 是最优解。
示例 3：
输入：nums = [1,2,3,4], x = 3
输出：3
解释：我们选择 nums[0] = 1 和 nums[3] = 4 。 它们下标距离满足至少为 3 ，差值绝对值为最小值 3 。 3 是最优解。
提示：
1 <= nums.length <= 1051 <= nums[i] <= 1090 <= x < nums.length
解题思路：
本题思路较为简单，但是在做题时需要注意双重for循环会出现超时情，因此需要借助TreeSet数据结构
首先需要先知道使用到的两个核心方法：
floor(E e)：返回此集合中最大的元素小于或等于给定元素，如果没有这样的元素，则返回 null
ceiliing(E e)：返回此集合中最小元素大于或等于给定元素，如果没有此元素，则返回 null
- 首先定义TreeSet集合用于维护符合条件的节点
- 遍历当前数组，遍历的索引初值为x
- 添加数组中第
x - i个元素到TreeSet中，在本次遍历过程中，第x - i个元素是符合条件的元素，在随后的遍历过程中，每一个符合条件的元素都会添加到TreeSet中 - 分别获取当前集合中 小于当前遍历值的最大值 和 大于当前遍历值的最小值 并分别获取到它们与当前遍历值的差值
- 记录当前最小差值
- 添加数组中第
- 返回最小差值
代码实现：
class Solution {
public int minAbsoluteDifference(List<Integer> nums, int x) {
// 定义返回值
int result = Integer.MAX_VALUE;
TreeSet<Integer> treeSet = new TreeSet<>();
// 一次遍历寻找
for (int i = x; i < nums.size(); i++) {
// 存储当前符合条件的节点值
treeSet.add(nums.get(i - x));
// 获取当前值
int num = nums.get(i);
// 获取小于当前值的最大值
Integer floor = treeSet.floor(num);
// 获取大于当前值的最小值
Integer ceil = treeSet.ceiling(num);
// 比较大于当前值的最小节点值 与 小于当前值的最大节点值 和当前值的差
if (floor != null) {
result = Math.min(Math.abs(floor - num), result);
}
if (ceil != null) {
result = Math.min(Math.abs(ceil - num), result);
}
}
return result;
}
}
4. 操作使得分最大
题目描述：
给你一个长度为 n 的正整数数组 nums 和一个整数 k 。
一开始，你的分数为 1 。你可以进行以下操作至多 k 次，目标是使你的分数最大：
- 选择一个之前没有选过的 非空 子数组 nums[l, …, r] 。
- 从 nums[l, …, r] 里面选择一个 质数分数 最高的元素 x 。如果多个元素质数分数相同且最高，选择下标最小的一个。
- 将你的分数乘以 x 。
nums[l, …, r] 表示 nums 中起始下标为 l ，结束下标为 r 的子数组，两个端点都包含。
一个整数的 质数分数 等于 x 不同质因子的数目。比方说， 300 的质数分数为 3 ，因为 300 = 2 * 2 * 3 * 5 * 5 。
请你返回进行至多 k 次操作后，可以得到的 最大分数 。
由于答案可能很大，请你将结果对 109 + 7 取余后返回
示例 1：
输入：nums = [8,3,9,3,8], k = 2
输出：81
解释：进行以下操作可以得到分数 81 ：
- 选择子数组 nums[2, …, 2] 。nums[2] 是子数组中唯一的元素。所以我们将分数乘以 nums[2] ，分数变为 1 * 9 = 9 。
- 选择子数组 nums[2, …, 3] 。nums[2] 和 nums[3] 质数分数都为 1 ，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 9 * 9 = 81 。
81 是可以得到的最高得分。
示例 2：
示例 2：
输入：nums = [19,12,14,6,10,18], k = 3
输出：4788
解释：进行以下操作可以得到分数 4788 ：
- 选择子数组 nums[0, …, 0] 。nums[0] 是子数组中唯一的元素。所以我们将分数乘以 nums[0] ，分数变为 1 * 19 = 19 。
- 选择子数组 nums[5, …, 5] 。nums[5] 是子数组中唯一的元素。所以我们将分数乘以 nums[5] ，分数变为 19 * 18 = 342 。
- 选择子数组 nums[2, …, 3] 。nums[2] 和 nums[3] 质数分数都为 2，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 342 * 14 = 4788 。
4788 是可以得到的最高的分。
提示：
1 <= nums.length == n <= 1051 <= nums[i] <= 1051 <= k <= min(n * (n + 1) / 2, 109)
暂时还没有想到怎么AC这道。。。