【力扣周赛】第 358 场周赛（大杂烩题目：质因数分解+快速幂+单调栈+贡献法）

已于 2023-11-27 00:35:46 修改
阅读量315 收藏
点赞数 1
分类专栏： 算法刷题记录 文章标签： leetcode 算法 质因数分解 单调栈 贪心 快速幂
于 2023-08-15 01:57:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/132258515
版权

文章目录

竞赛链接

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/

class Solution {
    public int maxSum(int[] nums) {
        int ans = -1, n = nums.length;
        int[] mx = new int[10];
        for (int v: nums) {
            int d = op(v);
            if (mx[d] != 0) ans = Math.max(ans, v + mx[d]);
            mx[d] = Math.max(mx[d], v);
        }
        return ans;
    }
    
    public int op(int n) {
        int res = -1;
        while (n != 0) {
            res = Math.max(res, n % 10);
            n /= 10;
        }
        return res;
    }
}

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：2818. 操作使得分最大（大杂烩：数学 + 单调栈(贡献法) + 贪心）

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;
    }

成绩记录

在这里插入图片描述

在这里插入图片描述

Wei *
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode176-leetcode-Weekly-competition-:力扣周赛
07-01
力扣周赛 特别感谢哔哩哔哩up主：喂你脚下有坑 我的不会的题目以及会的题目的改进基本都来自这位up的讲解视频 第167周周赛 题目:link:： 第168周周赛 题目:link:： 第170周周赛 题目:link:： 第171周周赛 题目:link:...
leetcode-CPP:力扣刷题C ++篇
03-27
栈 224.基本计算器 3.数组 26.删除排序列表中的重复项 4.数学问题 172.阶乘中的零 5.动态规划6.贪心算法7.二叉树 105.从前序和中序遍历建造二叉树 二叉树的深度 一体二叉树 8.斐波那契 跳台阶问题
Leetcode：力扣个人代码C ++
02-18
在力扣（LeetCode）平台上，C++是一种广泛使用的编程语言来解决算法和数据结构问题。这个名为"Leetcode：力扣个人代码C ++"的压缩包很可能包含了某位开发者或学习者用C++编写的解决LeetCode问题的代码集合。下面我们...
leetcode周赛难度-leetcode:leetcode
07-06
周赛难度LeetCode 题解 一题目列表 细绳 # 标题 标签 困难 解决方案 描述 1 细绳 中等的 2 细绳 中等的 3 细绳 中等的 4 细绳 中等的 DP # 标题 标签 困难 解决方案 描述 1 DP 中等的 2 DP 中等的 3 DP 中等的 4 DP ...
C#实现力扣双周赛算法题：以组为单位订音乐会的门票订购
06-14
在本项目中，我们主要探讨的是如何使用C#和Python编程语言来解决力扣（LeetCode）双周赛中的一个算法问题，即“以组为单位订音乐会的门票订购”。这个问题涉及到了数据结构、算法设计以及面向对象编程等多个IT领域的...
刷leetcode中常用且有效的方法总结
路有瑶台的博客
07-04 274
刷题的时候经常会因为不知道一个方法多写很多行代码，既然有trick为何不用！你问我眼中为何常含泪水，因为我忘记方法忘的深沉。join（）是 Python 中的一个字符串方法，它用于将序列（如列表、元组、集合等，但集合需要首先转换为列表或其他有序序列，因为集合是无序的）中的元素以指定的字符连接生成一个新的字符串。方法来更新计数器中的计数。可以传递另一个可迭代对象或者另一个。提供了一个快速简单的方式来统计哈希对象在集合中出现的次数。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 252
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
【康复学习--LeetCode每日一题】3033. 修改矩阵
Puppet__的博客
07-05 341
给你一个下标从 0 开始、大小为 m x n 的整数矩阵 matrix ，新建一个下标从 0 开始、名为 answer 的矩阵。使 answer 与 matrix 相等，接着将其中每个值为 -1 的元素替换为所在列的 最大 元素。输入：matrix = [[1,2,-1],[4,-1,6],[7,8,9]]输出：[[1,2,9],[4,8,6],[7,8,9]]输入：matrix = [[3,-1],[5,2]]解释：上图显示了发生替换的元素（蓝色区域）。输出：[[3,2],[5,2]]
LeetCode
伴随着你
07-05 379
其次，这些题目在实际应用中有着广泛背景，例如“两数之和”可以应用于简单的加减运算，而“接雨水”则涉及到复杂的计算几何问题。最后，通过解答这些题目，求职者可以展示自己的逻辑思维能力和解决问题的方法，这在面试中尤为重要。在具体的实现技巧方面，双指针技术是一种常用的方法，例如在“盛最多水的容器”一题中，通过维护两个指针分别指向数组的两端，计算当前容量并在必要时移动指针，可以在线性时间内解决问题。哈希表也是常用技巧之一，如在“两数之和”的题目中，利用哈希表可以在单次遍历中找到目标值对应的两个数。
力扣-2529. 正整数和负整数的最大计数
ls3614140的博客
07-02 408
如果不是就按照代码中的逻辑求出对应的个数再比较大小。换句话讲，如果 nums 中正整数的数目是 pos ，而负整数的数目是 neg ，返回 pos 和 neg二者中的最大值。给你一个按 非递减顺序 排列的数组 nums ，返回正整数数目和负整数数目中的最大值。解释：共有 3 个正整数和 3 个负整数。解释：共有 2 个正整数和 3 个负整数。解释：共有 4 个正整数和 0 个负整数。输入：nums = [-3,-2,-1,0,0,1,2]输入：nums = [-2,-1,-1,1,2,3]
leetcode hot100
qq_43541423的博客
07-04 597
HashMap的含义比较晕，可以重做。
leetcode力扣_贪心思想
bici_1的博客
07-04 938
自己想了一下大概只能想到需要排序，因为这是一个区间，区间怎么排序呢，按照边界排序的话，排好了之后呢？你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。并且一旦这个孩子得到了满足，那么饼干的下标j和孩子的下标i均要直接加1进入下一次判断。假设你是一位很棒的家长，想要给你的孩子们一些小饼干。先将饼干大小和孩子的胃口大小都排序，再一一对比...需要注意的是for中的循环条件是饼干不是孩子，孩子加一的条件是。，这个孩子会得到满足。
Golang | Leetcode Golang题解之第222题完全二叉树的节点个数
weixin_66442839的博客
07-08 224
Golang | Leetcode Golang题解之第222题完全二叉树的节点个数
【哈希表】【字符串】个人练习-Leetcode-1814. Count Nice Pairs in an Array
Rstln的博客
07-04 954
题目链接：https://leetcode.cn/problems/count-nice-pairs-in-an-array/description/思路：一开始的思路是伪加法，取一个对，从低位开始加。看了题解才发现可以转换原等式为。，如果当前位不想等就返回。题目大意：给出一个数列。的值，这样复杂度就降为。
C语言 | Leetcode C语言题解之第222题完全二叉树的节点个数
最新发布
m0_59237910的博客
07-08 187
C语言 | Leetcode C语言题解之第222题完全二叉树的节点个数
Leetcode 115 不同的子序列
AI从业者的专栏
07-04 458
在实际应用中，推荐使用动态规划或递归加记忆化的方法来解决这类问题，因为它们具有更高的效率。动态规划方法通过填表的方式避免了重复计算，而递归加记忆化方法则通过记忆化来优化递归过程中的重复计算，两者都是解决这类问题的有效手段。
Java | Leetcode Java题解之第222题完全二叉树的节点个数
m0_57195758的博客
07-08 205
Java | Leetcode Java题解之第222题完全二叉树的节点个数
力扣双指针算法题目：移动零
m0_73426459的博客
07-03 254
cur遇到零之后，des就不走，但是cur要接着走，此时cur指向零，des指向cur之前一个非0元素。在下一个循环中，cur不指向0，cur和des同时向前走一格，此时des指向零，cur不指向零。在非零区段中，des和cur一定是紧挨着的且cur一定比des快（cur在des右边）这个题目的思路和“使用递归排序快速排序解决数组的排序问题”相同。指针des和cur向右遍历。使用双指针des和cur。
【CV炼丹师勇闯力扣训练营 Day24：§7 回溯3】
Tensorrrrrr的博客
07-05 1049
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]输入：s = “101023”
力扣里面哪些题考的是单调栈
05-25
单调栈是一种常用的数据结构，用于解决一类求 Next Greater Element（下一个更大元素）问题，包括以下一些力扣题目： 1. 739. 每日温度（Medium） 2. 496. 下一个更大元素 I（Easy） 3. 503. 下一个更大元素 II（Medium） 4. 84. 柱状图中最大的矩形（Hard） 5. 42. 接雨水（Hard） 除此之外，还有一些其他的题目也可以使用单调栈进行优化，比如： 1. 901. 股票价格跨度（Medium） 2. 402. 移掉K位数字（Medium） 3. 316. 去除重复字母（Hard） 需要注意的是，虽然单调栈的应用场景比较广泛，但并不是所有求 Next Greater Element 的问题都可以使用单调栈解决，有时候可能需要使用其他算法或数据结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值