双周赛110（模拟、枚举+哈希表）

双周赛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 <= 105
• 1 <= 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 <= 103
• 1 <= nums1[i] <= 103
• 0 <= nums2[i] <= 103
• nums1.length == nums2.length
• 0 <= 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;
    }
}