双周赛110（模拟、枚举+哈希表）
文章目录
- 双周赛110
-
- [2806. 取整购买后的账户余额](https://leetcode.cn/problems/account-balance-after-rounded-purchase/)
-
- 模拟
- [2807. 在链表中插入最大公约数](https://leetcode.cn/problems/insert-greatest-common-divisors-in-linked-list/)
-
- 模拟
- [2808. 使循环数组所有元素相等的最少秒数](https://leetcode.cn/problems/minimum-seconds-to-equalize-a-circular-array/)
-
- 枚举 + 哈希表
- [2809. 使数组和小于等于 x 的最少时间](https://leetcode.cn/problems/minimum-time-to-make-array-sum-at-most-x/)
-
- 贪心 + DP
双周赛110
2806. 取整购买后的账户余额
难度简单0
一开始，你的银行账户里有 100 块钱。
给你一个整数purchaseAmount ，它表示你在一次购买中愿意支出的金额。
在一个商店里，你进行一次购买，实际支出的金额会向 最近 的 10 的 倍数 取整。换句话说，你实际会支付一个 非负 金额 roundedAmount ，满足 roundedAmount 是 10 的倍数且 abs(roundedAmount - purchaseAmount) 的值 最小 。
如果存在多于一个最接近的 10 的倍数，较大的倍数 是你的实际支出金额。
请你返回一个整数，表示你在愿意支出金额为 purchaseAmount 块钱的前提下，购买之后剩下的余额。
注意： 0 也是 10 的倍数。
示例 1：
输入：purchaseAmount = 9
输出：90
解释：这个例子中，最接近 9 的 10 的倍数是 10 。所以你的账户余额为 100 - 10 = 90 。
示例 2：
输入：purchaseAmount = 15
输出：80
解释：这个例子中，有 2 个最接近 15 的 10 的倍数：10 和 20，较大的数 20 是你的实际开销。
所以你的账户余额为 100 - 20 = 80 。
提示：
0 <= purchaseAmount <= 100
模拟
class Solution:
# (n + 5) / 10 向下取整
def accountBalanceAfterPurchase(self, purchaseAmount: int) -> int:
return 100 - (purchaseAmount + 5) // 10 * 10
2807. 在链表中插入最大公约数
难度中等1
给你一个链表的头 head ，每个结点包含一个整数值。
在相邻结点之间，请你插入一个新的结点，结点值为这两个相邻结点值的 最大公约数 。
请你返回插入之后的链表。
两个数的 最大公约数 是可以被两个数字整除的最大正整数。
示例 1：
输入：head = [18,6,10,3]
输出：[18,6,6,2,10,1,3]
解释：第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。
- 18 和 6 的最大公约数为 6 ，插入第一和第二个结点之间。
- 6 和 10 的最大公约数为 2 ，插入第二和第三个结点之间。
- 10 和 3 的最大公约数为 1 ，插入第三和第四个结点之间。
所有相邻结点之间都插入完毕，返回链表。
示例 2：
输入：head = [7]
输出：[7]
解释：第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。
没有相邻结点，所以返回初始链表。
提示：
- 链表中结点数目在
[1, 5000]之间。 1 <= Node.val <= 1000
模拟
dummy写法
class Solution {
public ListNode insertGreatestCommonDivisors(ListNode head) {
ListNode dummy = new ListNode(-1, head);
ListNode cur = dummy;
while(cur.next != null && cur.next.next != null){
int tmp = gcd(cur.next.val, cur.next.next.val);
ListNode aa = new ListNode(tmp);
aa.next = cur.next.next;
cur.next.next = aa;
cur = aa;
}
return dummy.next;
}
public int gcd(int x, int y) {
return y == 0 ? x : gcd(y, x % y);
}
}
简洁写法：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def insertGreatestCommonDivisors(self, head: Optional[ListNode]) -> Optional[ListNode]:
cur = head
while cur.next:
cur.next = ListNode(gcd(cur.val, cur.next.val), cur.next)
cur = cur.next.next
return head
2808. 使循环数组所有元素相等的最少秒数
难度中等4
给你一个下标从 0 开始长度为 n 的数组 nums 。
每一秒，你可以对数组执行以下操作：
- 对于范围在
[0, n - 1]内的每一个下标i，将nums[i]替换成nums[i]，nums[(i - 1 + n) % n]或者nums[(i + 1) % n]三者之一。
注意，所有元素会被同时替换。
请你返回将数组 nums 中所有元素变成相等元素所需要的 最少 秒数。
示例 1：
输入：nums = [1,2,1,2]
输出：1
解释：我们可以在 1 秒内将数组变成相等元素：
- 第 1 秒，将每个位置的元素分别变为 [nums[3],nums[1],nums[3],nums[3]] 。变化后，nums = [2,2,2,2] 。
1 秒是将数组变成相等元素所需要的最少秒数。
示例 2：
输入：nums = [2,1,3,3,2]
输出：2
解释：我们可以在 2 秒内将数组变成相等元素：
- 第 1 秒，将每个位置的元素分别变为 [nums[0],nums[2],nums[2],nums[2],nums[3]] 。变化后，nums = [2,3,3,3,3] 。
- 第 2 秒，将每个位置的元素分别变为 [nums[1],nums[1],nums[2],nums[3],nums[4]] 。变化后，nums = [3,3,3,3,3] 。
2 秒是将数组变成相等元素所需要的最少秒数。
示例 3：
输入：nums = [5,5,5,5]
输出：0
解释：不需要执行任何操作，因为一开始数组中的元素已经全部相等。
提示：
1 <= n == nums.length <= 1051 <= nums[i] <= 109
枚举 + 哈希表
class Solution {
public int minimumSeconds(List<Integer> nums) {
Map<Integer, Integer> map = new HashMap<>(); // num, pre
Map<Integer, Integer> numans = new HashMap<>(); // num, curans
Map<Integer, Integer> mapstart = new HashMap<>(); // num, start
int ans = nums.size() / 2;
for(int i = 0; i < nums.size(); i++){
int num = nums.get(i);
if(!map.containsKey(num)){
map.put(num, i);
mapstart.put(num, i);
}else{
if(!numans.containsKey(num)) numans.put(num, 0);
int curans = Math.max((i - map.get(num)) / 2, numans.get(num));
numans.put(num, curans);
map.put(num, i);
}
}
for(Map.Entry<Integer, Integer> entry : numans.entrySet()){
int curans = Math.max(entry.getValue(), (mapstart.get(entry.getKey()) - map.get(entry.getKey()) + nums.size()) / 2);
ans = Math.min(ans, curans);
}
return ans;
}
}
简洁写法
class Solution {
public int minimumSeconds(List<Integer> nums) {
int n = nums.size();
Map<Integer, List<Integer>> map = new HashMap<>(); // 记录每个元素出现的位置下标
for(int i = 0; i < nums.size(); i++){
if(!map.containsKey(nums.get(i))) map.put(nums.get(i), new ArrayList<>());
map.get(nums.get(i)).add(i);
}
int ans = n / 2;
for(Map.Entry<Integer, List<Integer>> entry : map.entrySet()){
List<Integer> list = entry.getValue();
list.add(list.get(0) + n);
int mx = -1;
for(int j = 1; j < list.size(); j++){
mx = Math.max(mx, (list.get(j) - list.get(j-1)) / 2);
}
ans = Math.min(ans, mx);
}
return ans;
}
}
2809. 使数组和小于等于 x 的最少时间
难度困难4
给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2 。每一秒，对于所有下标 0 <= i < nums1.length ，nums1[i] 的值都增加 nums2[i] 。操作 完成后 ，你可以进行如下操作：
- 选择任一满足
0 <= i < nums1.length的下标i，并使nums1[i] = 0。
同时给你一个整数 x 。
请你返回使 nums1 中所有元素之和 小于等于 x 所需要的 最少 时间，如果无法实现，那么返回 -1 。
示例 1：
输入：nums1 = [1,2,3], nums2 = [1,2,3], x = 4
输出：3
解释：
第 1 秒，我们对 i = 0 进行操作，得到 nums1 = [0,2+2,3+3] = [0,4,6] 。
第 2 秒，我们对 i = 1 进行操作，得到 nums1 = [0+1,0,6+3] = [1,0,9] 。
第 3 秒，我们对 i = 2 进行操作，得到 nums1 = [1+1,0+2,0] = [2,2,0] 。
现在 nums1 的和为 4 。不存在更少次数的操作，所以我们返回 3 。
示例 2：
输入：nums1 = [1,2,3], nums2 = [3,3,3], x = 4
输出：-1
解释：不管如何操作，nums1 的和总是会超过 x 。
提示：
1 <= nums1.length <= 1031 <= nums1[i] <= 1030 <= nums2[i] <= 103nums1.length == nums2.length0 <= x <= 106
贪心 + DP
https://leetcode.cn/problems/minimum-time-to-make-array-sum-at-most-x/solution/jiao-ni-yi-bu-bu-si-kao-ben-ti-by-endles-2eho/
class Solution {
public int minimumTime(List<Integer> nums1, List<Integer> nums2, int x) {
int n = nums1.size(), s1 = 0, s2 = 0;
// 对下标数组排序，避免破坏 nums1 和 nums2 的对应关系
var ids = new Integer[n];
for (int i = 0; i < n; i++) {
ids[i] = i;
s1 += nums1.get(i);
s2 += nums2.get(i);
}
Arrays.sort(ids, (i, j) -> nums2.get(i) - nums2.get(j));
var f = new int[n + 1];
for (int i : ids)
for (int j = n; j > 0; j--)
f[j] = Math.max(f[j], f[j - 1] + nums1.get(i) + nums2.get(i) * j);
for (int t = 0; t <= n; t++)
if (s1 + s2 * t - f[t] <= x)
return t;
return -1;
}
}