周赛364（模拟+贪心，枚举，单调栈+前后缀分解，枚举+DFS）

最新推荐文章于 2024-06-15 23:36:03 发布
最新推荐文章于 2024-06-15 23:36:03 发布
阅读量134 收藏
点赞数
分类专栏： 算法刷题记录 # LC周赛 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42958831/article/details/133251993
版权

文章目录

周赛364

8048. 最大二进制奇数

简单

给你一个 二进制 字符串 s ，其中至少包含一个 '1' 。

你必须按某种方式 重新排列 字符串中的位，使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。

以字符串形式，表示并返回可以由给定组合生成的最大二进制奇数。

注意 返回的结果字符串 可以 含前导零。

示例 1：

输入：s = "010"
输出："001"
解释：因为字符串 s 中仅有一个 '1' ，其必须出现在最后一位上。所以答案是 "001" 。

示例 2：

输入：s = "0101"
输出："1001"
解释：其中一个 '1' 必须出现在最后一位上。而由剩下的数字可以生产的最大数字是 "100" 。所以答案是 "1001" 。

提示：

  • 1 <= s.length <= 100
  • s 仅由 '0' 和 '1' 组成
  • s 中至少包含一个 '1'

贪心 + 模拟

class Solution {
    public String maximumOddBinaryNumber(String s) {
        int cnt1 = 0, n = s.length();
        for(char c : s.toCharArray()){
            if(c == '1') cnt1 += 1;
        }
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < cnt1 - 1; i++){
            sb.append("1");
        }
        for(int i = 0; i < n - cnt1; i++){
            sb.append("0");
        }
        sb.append("1");
        return sb.toString();
    }   
}

100049. 美丽塔 I

中等

给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。

你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。

如果以下条件满足，我们称这些塔是 美丽 的：

  1. 1 <= heights[i] <= maxHeights[i]
  2. heights 是一个 山状 数组。

如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：

  • 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
  • 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= heights[k]

请你返回满足 美丽塔 要求的方案中，高度和的最大值 。

示例 1：

输入：maxHeights = [5,3,4,1,1]
输出：13
解释：和最大的美丽塔方案为 heights = [5,3,3,1,1] ，这是一个美丽塔方案，因为：
- 1 <= heights[i] <= maxHeights[i]  
- heights 是个山状数组，峰值在 i = 0 处。
13 是所有美丽塔方案中的最大高度和。

示例 2：

输入：maxHeights = [6,5,3,9,2,7]
输出：22
解释： 和最大的美丽塔方案为 heights = [3,3,3,9,2,2] ，这是一个美丽塔方案，因为：
- 1 <= heights[i] <= maxHeights[i]
- heights 是个山状数组，峰值在 i = 3 处。
22 是所有美丽塔方案中的最大高度和。

示例 3：

输入：maxHeights = [3,2,5,5,2,3]
输出：18
解释：和最大的美丽塔方案为 heights = [2,2,5,5,2,2] ，这是一个美丽塔方案，因为：
- 1 <= heights[i] <= maxHeights[i]
- heights 是个山状数组，最大值在 i = 2 处。
注意，在这个方案中，i = 3 也是一个峰值。
18 是所有美丽塔方案中的最大高度和。

提示：

  • 1 <= n == maxHeights <= 103
  • 1 <= maxHeights[i] <= 109

枚举

class Solution {
    // 观察到数据范围10^3,可以枚举每个点作为山峰
    public long maximumSumOfHeights(List<Integer> maxHeights) {
        long ans = 0;
        int n = maxHeights.size();
        for(int i = 0 ; i < n; i++){
            long heightsum = maxHeights.get(i);
            for(int j = i-1, curtop = maxHeights.get(i); j >= 0; j--){
                curtop = Math.min(curtop, maxHeights.get(j));
                heightsum += curtop;
            }
            for(int j = i+1, curtop = maxHeights.get(i); j < n; j++){
                curtop = Math.min(curtop, maxHeights.get(j));
                heightsum += curtop;
            }
            ans = Math.max(ans, heightsum);
        }
        return ans;
    }
}

100048. 美丽塔 II

中等

给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。

你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。

如果以下条件满足，我们称这些塔是 美丽 的：

  1. 1 <= heights[i] <= maxHeights[i]
  2. heights 是一个 山状 数组。

如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：

  • 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
  • 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= heights[k]

请你返回满足 美丽塔 要求的方案中，高度和的最大值 。

示例 1：

输入：maxHeights = [5,3,4,1,1]
输出：13
解释：和最大的美丽塔方案为 heights = [5,3,3,1,1] ，这是一个美丽塔方案，因为：
- 1 <= heights[i] <= maxHeights[i]  
- heights 是个山状数组，峰值在 i = 0 处。
13 是所有美丽塔方案中的最大高度和。

示例 2：

输入：maxHeights = [6,5,3,9,2,7]
输出：22
解释： 和最大的美丽塔方案为 heights = [3,3,3,9,2,2] ，这是一个美丽塔方案，因为：
- 1 <= heights[i] <= maxHeights[i]
- heights 是个山状数组，峰值在 i = 3 处。
22 是所有美丽塔方案中的最大高度和。

示例 3：

输入：maxHeights = [3,2,5,5,2,3]
输出：18
解释：和最大的美丽塔方案为 heights = [2,2,5,5,2,2] ，这是一个美丽塔方案，因为：
- 1 <= heights[i] <= maxHeights[i]
- heights 是个山状数组，最大值在 i = 2 处。
注意，在这个方案中，i = 3 也是一个峰值。
18 是所有美丽塔方案中的最大高度和。

提示：

  • 1 <= n == maxHeights <= 105
  • 1 <= maxHeights[i] <= 109

单调栈 + 前后缀分解

https://leetcode.cn/problems/beautiful-towers-ii/solutions/2456562/qian-hou-zhui-fen-jie-dan-diao-zhan-pyth-1exe/

class Solution {
    /** 
    10^5 次方数据，枚举每个点作为最大值会超时，怎么优化呢？
    
    计算从 a[0] 到 a[i] 形成山状数组的左侧递增段，元素和最大是多少，记到数组 pre[i] 中。
    计算从 a|i] 到 a[n-1] 形成山状数组的右侧递减段，元素和最大是多少，记到数组 suf[i] 中。
    答案就是 pre[i] + suf[i+1] 的最大值

    如何计算 pre 和 suf？ 单调栈
    用单调栈，元素值从栈底到栈顶严格递增
    以 suf 为例，我们从右往左遍历 a，设当前得到的元素和为 sum
    1. 如果 a[i] 大于栈顶的元素值，那么直接把 a[i] 加到 sum 中，同时把i入栈 (栈中只需要保存下标)
    2. 否则，只要 a[i] 小于等于栈顶元素值，就不断循环，把之前加到sum 的撤销掉。
            循环结束后，从 a[i] 到 a[j-1] (假设现在栈顶下标是 j) 都必须是 a，
            把 a[i]*(j-1) 加到 sum 中
     */
    public long maximumSumOfHeights(List<Integer> maxHeights) {
        int[] a = maxHeights.stream().mapToInt(i -> i).toArray();
        int n = a.length;
        long[] suf = new long[n+1];
        Deque<Integer> st = new ArrayDeque<>();
        st.push(n); // 哨兵
        long sum = 0;
        // 计算suf
        for(int i = n-1; i >= 0; i--){
            int x = a[i];
            while(st.size() > 1 && x <= a[st.peek()]){
                int j = st.pop(); 
                // 撤销之前加到 sum 中的
                sum -= (long)a[j] * (st.peek() - j);
            }
            sum += (long) x * (st.peek() - i); // 从 i 到 st.peek()-1 都是 x
            suf[i] = sum;
            st.push(i);
        }
        long ans = sum;
        st.clear();
        st.push(-1); // 哨兵
        long pre = 0;
        for(int i = 0; i < n; i++){
            int x = a[i];
            while(st.size() > 1 && x <= a[st.peek()]){
                int j = st.pop();
                // 撤销之前加到 sum 中的
                pre -= (long) a[j] * (j - st.peek());
            }
            pre += (long) x * (i - st.peek());// 从 st.peek()+1 到 i 都是 x
            ans = Math.max(pre + suf[i+1], ans);
            st.push(i);
        }
        return ans;
    }
}

小羊肖恩

10^5 次方数据，枚举每个点作为最大值会超时，怎么优化呢？

我们考虑从中间点往前的结果的数组，可以发现其是这么更新的:

假设以 i-1 位置为中间点的结果数组前缀为 nums[i-1]，那么 i 位置会**把其中大于上界的数改为上界，同时增加一个新的数。**而这个过程很类似于单调栈。

因为这个过程等价于，我们一旦结果的前缀中有更大的数，我们将其（整段）删掉，后面一整段区间换成新的数。

同时我们也可以对后缀进行相似的处理。得到前缀和后缀的结果后，我们将其加总即可得到每个点为中间点的答案，也就得到了这个问题的解

  1. “左边最近的更小值”是一个经典问题，可以用单调栈解决，详见 leetcode 496. 下一个更大元素 I。

  2. 改成去掉一些数变成先递增再递减，至少要去掉多少个数？

496. 下一个更大元素 I

简单

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。

示例 1：

输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：
- 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
- 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
- 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

示例 2：

输入：nums1 = [2,4], nums2 = [1,2,3,4].
输出：[3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：
- 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。
- 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。

提示：

  • 1 <= nums1.length <= nums2.length <= 1000
  • 0 <= nums1[i], nums2[i] <= 104
  • nums1和nums2中所有整数 互不相同
  • nums1 中的所有整数同样出现在 nums2 中

**进阶：**你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗？

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map = new HashMap<>();
        // 维护一个单调递减栈
        Deque<Integer> dq = new ArrayDeque<>();
        for(int num : nums2){
            // 弹出比当前值小的元素，记录该弹出值的下一个更大元素
            while(!dq.isEmpty() && num > dq.peekLast()){
                map.put(dq.pollLast(), num);
            }
            dq.addLast(num);
        }
        int n = nums1.length;
        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            res[i] = map.getOrDefault(nums1[i], -1);
        }
        return res;
    }
}

100047. 统计树中的合法路径数目

困难

给你一棵 n 个节点的无向树，节点编号为 1 到 n 。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示节点 ui 和 vi 在树中有一条边。

请你返回树中的 合法路径数目 。

如果在节点 a 到节点 b 之间 恰好有一个 节点的编号是质数，那么我们称路径 (a, b) 是 合法的 。

注意：

  • 路径 (a, b) 指的是一条从节点 a 开始到节点 b 结束的一个节点序列，序列中的节点 互不相同 ，且相邻节点之间在树上有一条边。
  • 路径 (a, b) 和路径 (b, a) 视为 同一条 路径，且只计入答案 一次 。

示例 1：

img

输入：n = 5, edges = [[1,2],[1,3],[2,4],[2,5]]
输出：4
解释：恰好有一个质数编号的节点路径有：
- (1, 2) 因为路径 1 到 2 只包含一个质数 2 。
- (1, 3) 因为路径 1 到 3 只包含一个质数 3 。
- (1, 4) 因为路径 1 到 4 只包含一个质数 2 。
- (2, 4) 因为路径 2 到 4 只包含一个质数 2 。
只有 4 条合法路径。

示例 2：

img

输入：n = 6, edges = [[1,2],[1,3],[2,4],[3,5],[3,6]]
输出：6
解释：恰好有一个质数编号的节点路径有：
- (1, 2) 因为路径 1 到 2 只包含一个质数 2 。
- (1, 3) 因为路径 1 到 3 只包含一个质数 3 。
- (1, 4) 因为路径 1 到 4 只包含一个质数 2 。
- (1, 6) 因为路径 1 到 6 只包含一个质数 3 。
- (2, 4) 因为路径 2 到 4 只包含一个质数 2 。
- (3, 6) 因为路径 3 到 6 只包含一个质数 3 。
只有 6 条合法路径。

提示：

  • 1 <= n <= 105
  • edges.length == n - 1
  • edges[i].length == 2
  • 1 <= ui, vi <= n
  • 输入保证 edges 形成一棵合法的树。

枚举 + DFS

0X3F：https://leetcode.cn/problems/count-valid-paths-in-a-tree/solutions/2456716/tu-jie-on-xian-xing-zuo-fa-pythonjavacgo-tjz2/

class Solution {
    private final static int MX = (int) 1e5;
    private final static boolean[] np = new boolean[MX + 1]; // 质数=false 非质数=true

    static {
        np[1] = true;
        for (int i = 2; i * i <= MX; i++) {
            if (!np[i]) {
                for (int j = i * i; j <= MX; j += i) {
                    np[j] = true;
                }
            }
        }
    }

    public long countPaths(int n, int[][] edges) {
        List<Integer>[] g = new ArrayList[n + 1];
        Arrays.setAll(g, e -> new ArrayList<>());
        for (var e : edges) {
            int x = e[0], y = e[1];
            g[x].add(y);
            g[y].add(x);
        }

        long ans = 0;
        int[] size = new int[n + 1];
        var nodes = new ArrayList<Integer>();
        for (int x = 1; x <= n; x++) {
            if (np[x]) { // 跳过非质数
                continue;
            }
            int sum = 0;
            for (int y : g[x]) { // 质数 x 把这棵树分成了若干个连通块
                if (!np[y]) {
                    continue;
                }
                if (size[y] == 0) { // 尚未计算过
                    nodes.clear();
                    dfs(y, -1, g, nodes); // 遍历 y 所在连通块，在不经过质数的前提下，统计有多少个非质数
                    for (int z : nodes) {
                        size[z] = nodes.size();
                    }
                }
                // 这 size[y] 个非质数与之前遍历到的 sum 个非质数，两两之间的路径只包含质数 x
                ans += (long) size[y] * sum;
                sum += size[y];
            }
            ans += sum; // 从 x 出发的路径
        }
        return ans;
    }

    private void dfs(int x, int fa, List<Integer>[] g, List<Integer> nodes) {
        nodes.add(x);
        for (int y : g[x]) {
            if (y != fa && np[y]) {
                dfs(y, x, g, nodes);
            }
        }
    }
}
Miraclo_acc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode周赛难度-leetcode:leetcode
07-06
周赛难度LeetCode 题解 一题目列表 细绳 # 标题 标签 困难 解决方案 描述 1 细绳 中等的 2 细绳 中等的 3 细绳 中等的 4 细绳 中等的 DP # 标题 标签 困难 解决方案 描述 1 DP 中等的 2 DP 中等的 3 DP 中等的 4 DP ...
leetcode176-leetcode-Weekly-competition-:力扣周赛
07-01
力扣周赛 特别感谢哔哩哔哩up主：喂你脚下有坑 我的不会的题目以及会的题目的改进基本都来自这位up的讲解视频 第167周周赛 题目:link:： 第168周周赛 题目:link:： 第170周周赛 题目:link:： 第171周周赛 题目:link:...
spoj 6779. Can you answer these queries VII（树链剖分）
绝望的乐园
02-01 1127
题意：给出一棵树，每个点有权值，有两种操作，一种是查询u到v路径之间最大连续子段和，另一种是修改u到v路径上的点权。 思路：树链剖分直接搞……终于把GSS系列都切掉了（泪目），之前看了看别人的树链剖分的写法，感觉自己写得实在是太挫了，所以这次按着别人的方式写了下，感觉还是挺好用的，也许是这题处理起来挺麻烦，代码还是写的非常长……查询的时候，不断维护到当前点的最大连续子段和以及到当前点的最
【力扣周赛】第 364 场周赛⭐（前后缀分解+单调栈&DFS技巧）
小威的博客
10-01 233
周赛题目本质上是求一种类似于「非质数-质数-非质数」的路径个数。贪心：最后一位保留一个 1，其余的 1 都放置在最开始的位置。建树的过程中，对于每个节点只保留与它相连的最大的那三条边即可。计算每一个位置作为最高点时的最大结果，对所有结果取最大。建树之后，枚举每条边作为中间边的情况，更新最大值。这两题的共同点在于「枚举中间」，请读者细细品味。很差劲，脑子是糊掉的。
letcode第85场双周赛&第307场周赛（Easy+Medium）
jdjhsj的博客
08-21 519
letcode第85场前三题：滑动窗口，动态规划，暴力模拟，差分数组，线段树 letcode第307场前三题：贪心，模拟，dfs，bfs，图
牛客小白月赛23 A-膜法记录（贪心+枚举）
Crush_Z
03-22 243
题目传送 用贪心的思想，先将行全部消灭，在判断列有多少，和b比较一下。 每一行可以消或不消，枚举2^n。 #include <iostream> #include <cstring> #include <set> using namespace std; const int maxm = 1e5 + 5; int n, m, a, b, flag; char ...
LeetCode 第 212 场周赛(枚举、排序、极小化极大值（二分+搜索、贪心
2401_84024576的博客
04-30 194
i
LeetCode 第 212 场周赛(枚举、排序、极小化极大值（二分+搜索、贪心+并查集
2401_85112052的博客
05-26 331
根据描述“如果一个元素是它所在行和列的最小值，那么它的秩为 1”，那么显然左下角和右上角元素的秩都是1，那么左上角的元素的秩无论是什么都会和“如果 p < q ，那么 rank§ < rank(q)”以及“如果 p = q ，那么 rank( p) = rank(q)”其中之一矛盾。但是还真有个它给出的实例无解： [[-37,-50,-3,44],[-37,46,13,-32],[47,-42,-3,-40],[-17,-22,-39,24]] 第二行第一个元素-37会出现矛盾。// 表示无可达道路。
蓝桥杯1024第 2 场算法双周赛题解+AC代码
qq_74861982的博客
10-25 979
思路：直接输出15即可思路：思维1.对于每一块地板，如果能被凑出来，那么一定是2*3地砖组合出来的，无论2*3地砖怎么放都为6的倍数，故长为n,宽为m的地板，n*m%6==0一定成立2.这里还要注意一个特判，就是如果长或宽为1，那么是6的倍数也无法满足要求（不能切割地砖）
周赛340（相同元素分组+前缀和，二分答案）
qq_42958831的博客
04-09 325
0x3f
【力扣周赛】第 113 场双周赛（贪心&异或性质&换根DP）
小威的博客
09-17 255
根据异或的性质，有 x ^ (i ^ x) = i, y ^ ((k - i) & y) = k - i，因此与 坐标 (x, y) 可以匹配的坐标是 (i ^ x, (k - i) ^ y)，其中 i 的取值范围是 0 ~ k。对于一个新的 x 和 y，他要和另外的坐标匹配之和为 k，最多有 k 中可能，即 —— 0 + k， 1 + (k - 1)，2 + (k - 2)，…所以在 2 和 3 匹配之后，当枚举到 5 时，可以使用 5 替换掉 3，重新将 3 放入待匹配队列中。第二次 dfs 求答案。
leetcode周赛积分-leetcode:leetcode刷题记录
07-07
leetcode周赛积分 leetcode 推荐 No. Problems Solutions Tag 32 DP, Stack 周赛 (weekly-content) No. Solutions Completion Date 2020.07.05 刷题记录 No. Problems Solutions Completion Date 329 2020.07.26 16 ...
leetcode周赛难度-leetcode:我的leetcode代码
07-06
周赛难度力码 的代码参考。 当然，我也会每周更新一些关于这些问题的注释，但不是全部。 欢迎开 issue 讨论！ 要求 Xcode C++ 11 问题 清单(链表) ID 标题 困难 解决方案 笔记 2 中等的 19 中等的 21 简单的 24 中等...
leetcode周赛得分3-mstcBlog:微博
07-07
leetcode周赛得分3
指针和数组
2301_77634163的博客
06-10 436
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 441
力扣136. 只出现一次的数字
[力扣题解] 236. 二叉树的最近公共祖先
东皇太一在此的博客
06-10 440
用深度搜索的思想（好吧，前序、中序、后序都是深搜思想），保存寻找路径，看看找到2个节点的路径的重合部分，就可以找到最近公共祖先；
算法day25
2202_76101487的博客
06-11 386
正值少年的日常打卡
oj赛(双周赛第二十四次)
04-07
双周赛第二十四次是指在某个OJ平台上举办的第24次双周赛。双周赛通常是定期举办的比赛，每两周一次，旨在提供一个竞技的环境，让参赛者能够锻炼编程能力、学习算法知识，并与其他参赛者进行交流和竞争。 在双周赛中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值