【力扣周赛】第 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/

【力扣周赛】第 358 场周赛_第1张图片
提示:

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/

【力扣周赛】第 358 场周赛_第2张图片
提示:
链表中节点的数目在范围 [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/

【力扣周赛】第 358 场周赛_第3张图片
提示:
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)

【力扣周赛】第 358 场周赛_第4张图片

floor():返回集合中小于或等于给定元素的最大元素,如果没有这样的元素,则返回null。
ceiling():返回集合中大于或等于给定元素的最小元素,如果不存在这样的元素则返回null。

Q4:7023. 操作使得分最大(大杂烩:数学 + 单调栈(贡献法) + 贪心)

https://leetcode.cn/problems/apply-operations-to-maximize-score/

【力扣周赛】第 358 场周赛_第5张图片

提示:
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/
【力扣周赛】第 358 场周赛_第6张图片

参见:【算法基础:数学知识】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;
    }

成绩记录

在这里插入图片描述

【力扣周赛】第 358 场周赛_第7张图片

你可能感兴趣的:(算法刷题记录,leetcode,算法,质因数分解,单调栈,贪心,快速幂)