【力扣周赛】第 358 场周赛
文章目录
- 竞赛链接
- Q1：6939. 数组中的最大数对和
-
- 竞赛时代码—— O ( n 2 ) O(n^2) O(n2)
- 解法2——一次遍历 O ( n ) O(n) O(n)，维护最大数位为 i 的元素的最大值
- Q2：6914. 翻倍以链表形式表示的数字
-
- 竞赛时代码——存入列表再计算
- 解法2——只有下一个节点大于 4 的时候，才会因为进位多加一
- Q3：7022. 限制条件下元素之间的最小绝对差
-
- 竞赛时代码——手写二分
- 写法2——使用API（TreeSet）
- Q4：7023. 操作使得分最大（大杂烩：数学 + 单调栈(贡献法) + 贪心）
-
- 竞赛时代码
- 相关子题目
-
- 质因数分解
-
- 求质因数分解
- 求质因数的数量
- 快速幂
- 成绩记录
竞赛链接
https://leetcode.cn/contest/weekly-contest-358/
Q1：6939. 数组中的最大数对和
https://leetcode.cn/problems/max-pair-sum-in-an-array/
提示：
2 <= nums.length <= 100
1 <= nums[i] <= 10^4
竞赛时代码—— O ( n 2 ) O(n^2) O(n2)
class Solution {
public int maxSum(int[] nums) {
int ans = -1, n = nums.length;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (op(nums[i]) == op(nums[j])) {
ans = Math.max(ans, nums[i] + nums[j]);
}
}
}
return ans;
}
public int op(int n) {
int res = -1;
while (n != 0) {
res = Math.max(res, n % 10);
n /= 10;
}
return res;
}
}
解法2——一次遍历 O ( n ) O(n) O(n)，维护最大数位为 i 的元素的最大值
https://leetcode.cn/problems/max-pair-sum-in-an-array/solutions/2385996/yi-ci-bian-li-by-endlesscheng-6zt9/
在这里插入代码片
Q2：6914. 翻倍以链表形式表示的数字
https://leetcode.cn/problems/double-a-number-represented-as-a-linked-list/
提示：
链表中节点的数目在范围 [1, 10^4] 内
0 <= Node.val <= 9
生成的输入满足：链表表示一个不含前导零的数字，除了数字 0 本身。
竞赛时代码——存入列表再计算
class Solution {
public ListNode doubleIt(ListNode head) {
// 存储列表
List<Integer> ls = new ArrayList<>();
while (head != null) {
ls.add(head.val);
head = head.next;
}
// 计算乘法
int n = ls.size(), c = 0;
for (int i = n - 1; i >= 0; --i) {
int v = ls.get(i) * 2 + c;
ls.set(i, v % 10);
c = v / 10;
}
// 存入链表
ListNode dummy = new ListNode(-1), prev = dummy;
if (c == 1) ls.add(0, 1);
for (int i = 0; i < n + c; ++i) {
ListNode cur = new ListNode(ls.get(i));
prev.next = cur;
prev = cur;
}
return dummy.next;
}
}
解法2——只有下一个节点大于 4 的时候，才会因为进位多加一
如果不考虑进位，就是每个节点的值乘以 2。
什么时候会受到进位的影响呢？只有下一个节点大于 4 的时候，才会因为进位多加一。
特别地，如果链表头的值大于 4，那么需要在前面插入一个新的节点。
class Solution {
public ListNode doubleIt(ListNode head) {
if (head.val > 4) head = new ListNode(0, head);
for (ListNode cur = head; cur != null; cur = cur.next) {
cur.val = cur.val * 2 % 10;
if (cur.next != null && cur.next.val > 4) cur.val++;
}
return head;
}
}
Q3：7022. 限制条件下元素之间的最小绝对差
https://leetcode.cn/problems/minimum-absolute-difference-between-elements-with-constraint/description/
提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= x < nums.length
竞赛时代码——手写二分
枚举 i 和 j ，其中 j = i + x，这样从 0 ~ i 范围内都是 nums[j] 可以配对的数字。
将 0 ~ i 的数字排序之后，就可以使用二分查找寻找其中最接近 nums[j] 的数字了。
class Solution {
public int minAbsoluteDifference(List<Integer> nums, int x) {
int n = nums.size(), ans = Integer.MAX_VALUE;
List<Integer> ls = new ArrayList(); // 维护前面元素的有序序列（升序）
for (int i = 0, j = x; j < n; ++i, ++j) {
// 将nums[i]加入有序序列ls，使用二分查找寻找nums[i]应该插入的位置。
int l = 0, r = ls.size(), v = nums.get(i);
while (l < r) {
int mid = l + r >> 1;
if (ls.get(mid) <= v) l = mid + 1;
else r = mid;
}
ls.add(l, v);
// 使用二分查找寻找前面序列中最后一个<=nums[j]的元素
l = 0;
r = ls.size() - 1;
v = nums.get(j);
while (l < r) {
int mid = l + r + 1 >> 1;
if (ls.get(mid) > v) r = mid - 1;
else l = mid;
}
// 使用和nums[j]最接近的元素更新答案
ans = Math.min(ans, Math.abs(v - ls.get(l)));
if (l + 1 < ls.size()) ans = Math.min(ans, Math.abs(ls.get(l + 1) - v));
}
return ans;
}
}
写法2——使用API（TreeSet）
排序 和 二分查找的过程都可以使用 JDK 来实现。
class Solution {
public int minAbsoluteDifference(List<Integer> nums, int x) {
int n = nums.size(), ans = Integer.MAX_VALUE;
TreeSet<Integer> s = new TreeSet<>();
s.add(Integer.MAX_VALUE);
s.add(Integer.MIN_VALUE / 2);
for (int i = x; i < n; ++i) {
s.add(nums.get(i - x));
int y = nums.get(i);
ans = Math.min(ans, Math.min(s.ceiling(y) - y, y - s.floor(y)));
}
return ans;
}
}
TreeSet 会自动排序，关于 TreeSet 可见：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/TreeSet.html#ceiling(E)
floor()：返回集合中小于或等于给定元素的最大元素，如果没有这样的元素，则返回null。
ceiling()：返回集合中大于或等于给定元素的最小元素，如果不存在这样的元素则返回null。
Q4：7023. 操作使得分最大（大杂烩：数学 + 单调栈(贡献法) + 贪心）
https://leetcode.cn/problems/apply-operations-to-maximize-score/
提示：
1 <= nums.length == n <= 10^5
1 <= nums[i] <= 10^5
1 <= k <= min(n * (n + 1) / 2, 10^9)
竞赛时代码
我们考虑每个数字 x 对应的 l ~ r 的范围，就是元素 x 可以被选择的次数。
一共可以选择 k 次，所以我们应该将元素按照贡献的能力排序，尽量选贡献大的，其中每个元素 x 可以被选择的次数通过单调栈求出 l ~ r 的范围即可。
质数分数的求法：质因数分解。
k 次操作之后的分数的求法：因为 k 可能很大，所以需要使用快速幂。
class Solution {
final long MOD = (long)1e9 + 7;
public int maximumScore(List<Integer> nums, int k) {
int n = nums.size();
int[][] scores = new int[n][2];
for (int i = 0; i < n; ++i) {
scores[i][0] = op(nums.get(i)); // 求质数分数
}
Deque<Integer> stk = new ArrayDeque<>();
int[] l = new int[n], r = new int[n]; // 存储各个元素对应可以选择的l~r范围
Arrays.fill(l, -1);
Arrays.fill(r, n);
for (int i = 0; i < n; ++i) {
while (!stk.isEmpty() && scores[i][0] > scores[stk.peek()][0]) {
r[stk.pop()] = i;
}
if (!stk.isEmpty()) l[i] = stk.peek();
stk.push(i);
}
for (int i = 0; i < n; ++i) {
scores[i][0] = nums.get(i); // 元素的贡献
scores[i][1] = (r[i] - i) * (i - l[i]); // 元素可以被选择的次数
}
// 排序+贪心找 k次操作对应哪些元素
Arrays.sort(scores, (x, y) -> y[0] - x[0]); // 分数倒序排序
int sum = 0, id = 0, c = 0;
for (int i = 0; i < n; ++i) {
if (sum + scores[i][1] <= k) {
sum += scores[i][1];
id = i;
c = scores[i][1];
}
else {
id = i;
c = k - sum;
break;
}
}
long ans = 1;
ans = (ans * qmi((long)scores[id][0], (long)c)) % MOD; // 把最后一个选c次的放进去
for (int i = id - 1; i >= 0; --i) {
ans = (ans * qmi((long)scores[i][0], (long)scores[i][1])) % MOD;
}
return (int)ans;
}
// 质因数分解 得到不同质因数的数量
public int op(int x) {
int res = 0;
for (int i = 2; i <= x / i; ++i) {
if (x % i == 0) {
res++;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) res++;
return res;
}
// 快速幂
public long qmi(long a, long b) {
long p = MOD;
long res = 1 % p, t = a;
while (b != 0) {
if ((b & 1) == 1) res = res * t % p;
t = t * t % p;
b >>= 1;
}
return res;
}
}
相关子题目
质因数分解
求质因数分解
867. 分解质因数 https://www.acwing.com/problem/content/869/
见：https://blog.csdn.net/qq_43406895/article/details/131843296
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
while (n-- != 0) {
divide(sc.nextInt());
}
}
static void divide(int x) {
for (int i = 2; i <= x / i; ++i) {
if (x % i == 0) {
int s = 0;
while (x % i == 0) { // 把 x 中的 i 除干净
s++;
x /= i;
}
System.out.println(i + " " + s);
}
}
if (x > 1) System.out.println(x + " " + 1); // 注意要判断最后剩下的没被除掉的质因数
System.out.println();
}
}
求质因数的数量
如果是只求质因数的数量的话，那么可以在筛质数的过程中记录质因数的数量。
对应解决这道题目的代码如下：
class Solution {
final long MOD = (long)1e9 + 7;
final static int MX = (int)1e5 + 1;
// 求各个数字的不同质因数的数量
static int[] omega = new int[MX];
static {
for (int i = 2; i < MX; ++i) {
if (omega[i] == 0) { // i 是质数
for (int j = i; j < MX; j += i) {
omega[j]++; // i 是 j 的一个质因子
}
}
}
}
public int maximumScore(List<Integer> nums, int k) {
int n = nums.size();
int[][] scores = new int[n][2];
for (int i = 0; i < n; ++i) {
scores[i][0] = op(nums.get(i)); // 求质数分数
}
Deque<Integer> stk = new ArrayDeque<>();
int[] l = new int[n], r = new int[n]; // 存储各个元素对应可以选择的l~r范围
Arrays.fill(l, -1);
Arrays.fill(r, n);
for (int i = 0; i < n; ++i) {
while (!stk.isEmpty() && scores[i][0] > scores[stk.peek()][0]) {
r[stk.pop()] = i;
}
if (!stk.isEmpty()) l[i] = stk.peek();
stk.push(i);
}
for (int i = 0; i < n; ++i) {
scores[i][0] = nums.get(i); // 元素的贡献
scores[i][1] = (r[i] - i) * (i - l[i]); // 元素可以被选择的次数
}
// 排序+贪心找 k次操作对应哪些元素
Arrays.sort(scores, (x, y) -> y[0] - x[0]); // 分数倒序排序
int sum = 0, id = 0, c = 0;
for (int i = 0; i < n; ++i) {
if (sum + scores[i][1] <= k) {
sum += scores[i][1];
id = i;
c = scores[i][1];
}
else {
id = i;
c = k - sum;
break;
}
}
long ans = 1;
ans = (ans * qmi((long)scores[id][0], (long)c)) % MOD; // 把最后一个选c次的放进去
for (int i = id - 1; i >= 0; --i) {
ans = (ans * qmi((long)scores[i][0], (long)scores[i][1])) % MOD;
}
return (int)ans;
}
// 质因数分解 得到不同质因数的数量
public int op(int x) {
return omega[x];
}
// 快速幂
public long qmi(long a, long b) {
long p = MOD;
long res = 1 % p, t = a;
while (b != 0) {
if ((b & 1) == 1) res = res * t % p;
t = t * t % p;
b >>= 1;
}
return res;
}
}
快速幂
力扣题目链接：https://leetcode.cn/problems/powx-n/
参见：【算法基础：数学知识】4.4 快速幂
递归版——
static long qmi(long a, long b, long p) {
if (b == 0) return 1;
long res = qmi(a, b / 2, p) % p;
if (b % 2 == 0) return res * res % p;
else return res * res * a % p;
}
迭代版——
static long qmi(long a, long b, long p) {
long res = 1 % p, t = a;
// 把 b 看成二进制数字，哪些位置是 1 就把它乘起来就好了
while (b != 0) {
if ((b & 1) == 1) res = res * t % p;
t = t * t % p;
b >>= 1;
}
return res;
}
成绩记录
