2024.05.26 第 399 场周赛

Leetcode 第 399 场周赛

优质数对的总数 I

Leetcode 优质数对的总数 I

给你两个整数数组 nums1 和 nums2，长度分别为 n 和 m。同时给你一个正整数 k。
如果 nums1[i] 可以被 nums2[j] * k 整除，则称数对 (i, j) 为 优质数对（0 <= i <= n - 1, 0 <= j <= m - 1）。
返回** 优质数对 **的总数。

遍历每一对数字，判断是否符合要求

完整代码

class Solution {
    public int numberOfPairs(int[] nums1, int[] nums2, int k) {
        int res = 0;
        int n = nums1.length;
        int m = nums2.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (nums1[i] % (nums2[j] * k) == 0) res++;
            }
        }
        return res;
    }
}

压缩字符串 III

Leetcode 压缩字符串 III

给你一个字符串 word，请你使用以下算法进行压缩：

• 从空字符串 comp 开始。当 word 不为空 时，执行以下操作：
  • 移除 word 的最长单字符前缀，该前缀由单一字符 c 重复多次组成，且该前缀长度 **最多 **为 9 。
  • 将前缀的长度和字符 c 追加到 comp 。

返回字符串 comp 。

对字母进行计数，加入字符串即可。
注意：这里不要使用 String 保存结果，使用可追加的 StringBuffer 或 StringBuilder 保存结果。

完整代码

class Solution {
    public String compressedString(String word) {
        int n = word.length();
        StringBuilder res = new StringBuilder();
        char c = word.charAt(0);
        int count = 1;
        for (int i = 1; i < n; i++) {
            if (word.charAt(i) == c) count++;
            else {
                if (count != 0) {
                    res.append(count);
                    res.append(c);
                }
                count = 1;
                c = word.charAt(i);
            }
            
            if (count == 9) {
                res.append(count);
                res.append(c);
                count = 0;
            }
        }
        if (count != 0) {
            res.append(count);
            res.append(c);
        }
        
        return String.valueOf(res);    
    }
}

后记：

1. String、StringBuffer 和 StringBuilder 的异同
   - String 把数据放在常量池中，默认一常量形式保存，且有 final 修饰，因此不可追加，追加之后会创建新的对象。
   - StringBuffer 是可追加的，且线程安全，但是效率比 StringBuilder 低。
   - StringBuilder 也是可追加的，但是线程不安全，但效率是最高的。

优质数对的总数 II

Leetcode 优质数对的总数 II

题目与 1 相同，只是数据量更大。

提示：

• 1 <= n, m <= 105
• 1 <= nums1[i], nums2[j] <= 106
• 1 <= k <= 103

先将数据排序，如果当前被除数大于除数，后面就不需要判断了。

完整代码

class Solution {
    public long numberOfPairs(int[] nums1, int[] nums2, int k) {
        int res = 0;

        List<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        int n = nums1.length;
        int m = nums2.length;
        
        for (int i = 0; i < n; i++) {
            list1.add(nums1[i]);
        }
        for (int i = 0; i < m; i++) {
            list2.add(nums2[i] * k);
        }
        
        Collections.sort(list1);
        Collections.sort(list2);
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (list2.get(j) > list1.get(i)) break;
                if (list1.get(i) % list2.get(j) == 0) res++;
            }
        }
        return res;
    }
}

还是超出时间限制（哭）。

不包含相邻元素的子序列

Leetcode 不包含相邻元素的子序列

给你一个整数数组 nums 和一个二维数组 queries，其中 queries[i] = [posi, xi]。
对于每个查询 i，首先将 nums[posi] 设置为 xi，然后计算查询 i 的答案，该答案为 nums 中 **不包含相邻元素 **的子序列的 **最大 **和。
返回所有查询的答案之和。
由于最终答案可能非常大，返回其对 109 + 7 取余 的结果。
子序列 是指从另一个数组中删除一些或不删除元素而不改变剩余元素顺序得到的数组。

没写，之后再看。。。。。