Acwing 周赛132 解题报告 | 珂学家 | 并查集 + floyd寻路

已于 2024-03-02 14:53:14 修改
阅读量971 收藏 11
点赞数 12
分类专栏： Acwing周赛 解题报告 文章标签： 算法 python 数据库 开发语言 娱乐 leetcode
于 2024-03-02 14:01:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66102593/article/details/136414872
版权

前言

在这里插入图片描述

整体评价

A. 大小写转换

Q: 把字符串s统一成小写字母形态

题型：签到

知识点: 考察字符串的API题

c++可以借助transform函数，进行转化

#include <bits/stdc++.h>

using namespace std;

int main() {
    string s;
    cin >> s;
    // 把自己转化为小写/大写态
    // tolower/toupper
    transform(s.begin(), s.end(), s.begin(), ::tolower);
    cout << s << endl;
    return 0;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) {
        AReader sc = new AReader();
        String s = sc.next();
        System.out.println(s.toLowerCase());
    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

//        public BigInteger nextBigInt() {
//            return new BigInteger(next());
//        }
        // 若需要nextDouble等方法，请自行调用Double.parseDouble包装
    }

}

B. 不合群数

Q: 不能被 [2, a]范围内的数整除的数，被称为不合群数， 求[2, b]内最大的不合群数

思路: 枚举

核心就是，一个前置的知识点:

10 亿内的最大质数是 999999937 ，且相邻质数之间的差值均不超过 300 10 亿内的最大质数是 999999937，且相邻质数之间的差值均不超过 300 10亿内的最大质数是999999937，且相邻质数之间的差值均不超过300

因为大于a的质数，一定是不合群数，而每300数，必然有一个质数存在。因此找到这个质数即可。

从b开始，从大到小进行枚举，判定即可。

当然不见得质数才满足需求

比如

input
5 50

output
49
# 因为49=7*7， 其不被[2, 5]区间的数整除

但是质数，给了枚举范围的上限值，所以这是一道很有趣的题。

#include <bits/stdc++.h>

using namespace std;

using int64 = int64_t;

// 判定质数, O(sqrt(n))
bool judge(int64 v, int64 a) {
    if (v <= a) return false;
    for (int64 i = 2; i <= v / i && i <= a; i++) {
        if (v % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    int64 a, b;
    cin >> a >> b;
    
    int64 res = -1;
    for (int64 i = b; i >= max(b - 300, a + 1); i--) {
        if (judge(i, a)) {
            res = i;
            break;
        }
    }
    cout << res << endl;
    return 0;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {

    static boolean isPrime(long v) {
        if (v <= 1) return false;
        for (int i = 2; i <= v / i; i++) {
            if (v % i == 0) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        AReader sc = new AReader();

        long a = sc.nextLong(), b = sc.nextLong();

        long res = -1;
        for (long i = b; i > a && i >= b - 300; i--) {
            // a^2
            if (isPrime(i)) {
                res = i;
                break;
            }
            if (i >= a * a) {
                boolean ok = true;
                for (int j = 2; j <= a; j++) {
                    if (i % j == 0) {
                        ok = false;
                    }
                }
                if (ok) {
                    res = i;
                    break;
                }
            }
        }
        System.out.println(res);

    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

//        public BigInteger nextBigInt() {
//            return new BigInteger(next());
//        }
        // 若需要nextDouble等方法，请自行调用Double.parseDouble包装
    }

}

C. 最短距离

Q: 在一个无向图中，同类点需保证任意两点间最短距离为0，然后求非同类点的距离矩阵

思路: 图论+缩点思路

这边不是tanjar求缩点，

借助并查集来合并 借助并查集来合并 借助并查集来合并

把边长为0的两点进行合并，这样就能快速判定是否满足第一个条件(注意借桥搭路)

然后根据缩点后，进行路径的压缩k*k

跑一遍floyd就可以出来了

#include <bits/stdc++.h>

using namespace std;

class Dsu {
public:
    Dsu(int n) : n(n), arr(n + 1) {
    }
    
    int find(int u) {
        if (arr[u] == 0) return u;
        return arr[u] = find(arr[u]);
    }
    
    void merge(int u, int v) {
        int ai = find(u), bi = find(v);
        if (ai != bi) {
            arr[ai] = bi;
        }
    }
    
    bool isSame(int u, int v) {
        return find(u) == find(v);
    }
    
private:
    int n;
    vector<int> arr;
};

int main() {
    
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, m, k;
    cin >> n >> m >> k;
    
    vector<int> cats(k);
    for (int i = 0; i < k; i++) {
        cin >> cats[i];
    }
    
    Dsu dsu(n);
    vector<array<int, 3>> edges;
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        edges.push_back({u, v, w});
        
        if (w == 0) {
            dsu.merge(u, v);
        }
    }
    
    bool ok = true;
    int start = 1;
    vector<int> mp(n + 1);
    for (int i = 0; i < cats.size(); i++) {
        for (int j = start + 1; j < start + cats[i]; j++) {
            if (!dsu.isSame(start, j)) {
                ok = false;
                break;
            }
        }
        for (int j = start; j < start + cats[i]; j++) mp[j] = i;
        start = start + cats[i];
    }
    
    if (!ok) {
        cout << "No" << endl;
    } else {
        cout << "Yes" << endl;
        int inf = -1;
        vector<vector<int>> path(k, vector<int>(k, -1));
        for (int i = 0; i < k; i++) path[i][i] = 0;
        
        for (auto e: edges) {
            int u = mp[e[0]],  v = mp[e[1]];
            if (path[u][v] == -1 || path[u][v] > e[2]) {
                path[u][v] = path[v][u] = e[2];
            }
        }
        
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < k; j++) {
                if (path[j][i] == -1) continue;
                for (int t = 0; t < k; t++) {
                    if (path[i][t] == -1) continue;
                    if (path[j][t] == -1 || path[j][t] > path[j][i] + path[i][t]) {
                        path[j][t] = path[j][i] + path[i][t];
                    }
                }
            }
        }
        
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < k; j++) {
                cout << path[i][j] << " \n"[j == k - 1];
            }
        }
        
    }
    
    
    return 0;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    static class Dsu {
        int n;
        int[] arr;
        int[] gz;
        public Dsu(int n) {
            this.n = n;
            this.arr = new int[n + 1];
            this.gz = new int[n + 1];
            Arrays.fill(gz, 1);
        }

        int find(int u) {
            if (arr[u] == 0) return u;
            return arr[u] = find(arr[u]);
        }

        void union(int u,int v) {
            int ai = find(u), bi = find(v);
            if (ai != bi) {
                arr[ai] = bi;
                gz[bi] += gz[ai];
            }
        }

        int gSize(int u) {
            return gz[find(u)];
        }

    }

    public static void main(String[] args) {
        AReader sc = new AReader();
        int n = sc.nextInt(), m = sc.nextInt();
        int k = sc.nextInt();
        int[] arr = new int[k];

        int acc = 1;
        TreeMap<Integer, Integer> hash = new TreeMap<>();
        for (int i = 0; i < k; i++) {
            arr[i] = sc.nextInt();
            hash.put(acc, i);
            acc += arr[i];
        }

        long inf = Long.MAX_VALUE / 10;
        long[][] dp = new long[k][k];
        for (int i = 0; i < k; i++) {
            Arrays.fill(dp[i], inf);
            dp[i][i] = 0;
        }

        Dsu dsu = new Dsu(n);
        for (int i = 0; i < m; i++) {
            int u = sc.nextInt(), v = sc.nextInt();
            int x = sc.nextInt();
            Map.Entry<Integer, Integer> e1 = hash.floorEntry(u);
            Map.Entry<Integer, Integer> e2 = hash.floorEntry(v);

            int p1 = e1.getValue(), p2 = e2.getValue();
            if (p1 == p2) {
            } else {
                dp[p1][p2] = Math.min(dp[p1][p2], x);
                dp[p2][p1] = Math.min(dp[p2][p1], x);
            }

            if (x == 0) {
                dsu.union(u, v);
            }
        }

        boolean check = true;
        acc = 1;
        for (int i = 0; i < k; i++) {
            for (int j = acc; j < acc + arr[i]; j++) {
                if (dsu.find(acc) != dsu.find(j)) check = false;
            }
            acc += arr[i];
        }

        if (!check) {
            System.out.println("No");
        } else {

            System.out.println("Yes");
            for (int i = 0; i < k; i++) {
                for (int j = 0; j < k; j++) {
                    for (int t = 0; t < k; t++) {
                        if (dp[j][t] > dp[j][i] + dp[i][t]) {
                            dp[j][t] = dp[j][i] + dp[i][t];
                        }
                    }
                }
            }

            for (int i = 0; i < k; i++) {
                for (int j = 0; j < k; j++) {
                    if (dp[i][j] == inf) dp[i][j] = -1;
                }
                System.out.println(Arrays.stream(dp[i]).mapToObj(String::valueOf).collect(Collectors.joining(" ")));
            }
        }

    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

//        public BigInteger nextBigInt() {
//            return new BigInteger(next());
//        }
        // 若需要nextDouble等方法，请自行调用Double.parseDouble包装
    }

}

写在最后

珂朵莉酱
关注
  • 12
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【力扣夜猫双周赛】第24场 | 5372，5373，5374，5374 | 动态规划 |回溯算法
01-21
你需要从左到右遍历 nums 数组，并将 startValue 依次累加上 nums 数组中的值。 请你在确保累加和始终大于等于 1 的前提下，选出一个最小的 正数 作为 startValue 。 输入：nums = [-3,2,-3,4,2] 输出：5 解释：如果...
制做并调试电动赛车(无束圆周赛).pdf
12-04
【制作电动赛车(无束圆周赛)】教学目标与知识点 本次教学的主题是制作捷豹电动赛车，旨在让学生了解电动车的基本构造和工作原理，同时培养他们的实践技能和团队合作精神。以下是具体的知识点和教学内容： 1. **...
算法题的提交答案，并随着每周的周赛等新增题目更新。编程语言以 C++ 为主
01-03
【标题】中的“算法题的提交答案，并随着每周的周赛等新增题目更新。编程语言以 C++ 为主”这部分信息表明，这是一个关于算法实践和竞赛的项目，主要使用 C++ 进行编程。通常这样的项目涉及到算法设计、实现、调试和...
leetcode周赛难度-leetcode:leetcode
07-06
周赛难度LeetCode 题解 一题目列表 细绳 # 标题 标签 困难 解决方案 描述 1 细绳 中等的 2 细绳 中等的 3 细绳 中等的 4 细绳 中等的 DP # 标题 标签 困难 解决方案 描述 1 DP 中等的 2 DP 中等的 3 DP 中等的 4 DP ...
工作述职报告模板集锦八篇_3.docx
10-07
【工作述职报告】是个人或组织定期向上级或者公众汇报工作情况的一种正式文档，它通常包含个人或团队在过去一段时间内的工作内容、工作成果、遇到的问题、改进措施以及对未来工作的规划等方面。在这个特定的"工作...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 956
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 254
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 305
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 463
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1086
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1112
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
LeetCode-day25-2844. 生成特殊数字的最少操作
小李的便利店
07-25 466
2844. 生成特殊数字的最少操作
力扣题解（最大数）
yyssas的博客
07-24 361
因此按照上述做法得出的序列是x1,x2,x3.....,最优解是y1,y2,y3.....,假设前i-1个一样，则xi！=yi，假设xi==yj，则必有yiyj<yjyi，且对于处于i到j之间的数字组合z，yizyj<yjzyi，因此换i，j位置会大于等于未换位置的最优解，但是最优解是最大值，因此换后仍是最大值。正确性：若ab>ba,则acb>bca，保证了将任何数放ab之间，不改变大小关系。排序规则：对于数组中的数a和数b，若ab>ba，则a在前，b在后。对数组重新排列，使得按照题目所要求的顺序输出。
【常微分方程】
qq_74285286的博客
07-24 393
常微分方程笔记
小红书（社招二面）算法原题
宫水三叶的刷题日记
07-25 920
但如果从百度（甚至是社会交通运输行业）的角度出发，萝卜快跑还是一个尚未全国铺开的产品，甚至还是一个内测产品，同时也代表了一个未来很有前景的行业，现如今却落入"抢人类饭碗"的社会问题舆论中，很容易就会导致整个行业被扼杀。从现在的环境分析，萝卜快跑的流量已经上来了，此时选择涨价到正常水平，可以进一步平衡订单的供求关系，又可以让舆论冷却，还能达成当时补贴是「为了拿到更多真实数据」的目的，是最符合经济原则的做法。首先，萝卜快跑的定价权是在百度手上的，萝卜快跑如今选择涨价，和网约车保持相当的水准。
leetcode10 -- 正则表达式匹配
m0_65985318的博客
07-24 1515
那么如果s的第i个字符和p的第j个字符匹配的话，即当s[i-1]=p[j-1]（字符相等）或者p[j-1]='.'（.可以替代任意单个字符）时，两个串是否匹配则取决于除末尾位之外的剩余子串是否匹配，即s的前i-1个字符与p的前j-1个字符是否匹配，也就是dp[i][j]=dp[i-1][j-1]。用dp[i][j]表示s的前i个字符（s下标为0~i-1）与p的前j个字符（p下标为0~j-1）是否匹配，即如果dp[i][j]为true，s的前i个字符与p的前j个字符匹配，反之不匹配。，请你来实现一个支持。
算法与算法分析
最新发布
2303_78660417的博客
07-25 1125
算法就是对特定问题求解方法和步骤的一种描述，它是指令的有限序列。其中，每个指令表示一个或多个操作。总而言之，我们数据结构就是通过算法实现操作。而我们的算法又是根据数据结构来设计程序。程序=数据结构+算法。
C语言刷题小记2
2302_81486993的博客
07-24 787
分析：拿到这道题，大家可能会有一种思路，就是创建一个新数组，然后进行判断，判断结束后将符合条件的元素再插入到新数组，这种想法其实是正确的，但是很可惜，本题不能用这样的方法，因为题目要求不能使用额外的数组空间，这就意味着我们是不能创建新数组的，所以本题就需要采取其他做法；大家来看，这里我分装了一个函数，里面实现的就是冒泡排序的逻辑，在主函数中，我们创建了数组去存储我们输入的成绩，然后将数据交给函数进行排序，最终我们需要返回的就是最大值；反之，我们将最后一位去除掉，将其后一位作为最后一位，再次进行判断。
LeetCode977 有序数组的平方
daishabby2486的博客
07-24 1118
LeetCode977 有序数组的平方的解题记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值