Codeforces Round 976 Problem D. Connect the Dots

于 2024-10-05 19:51:22 发布
阅读量421 收藏 14
点赞数 8
文章标签： java idea 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/selfcenter/article/details/142715015
版权

D. Connect the Dots

文章目录

题意

在这里插入图片描述

D. 连点成线

每个测试的时间限制：2 秒
每个测试的内存限制：512 兆字节

一个美好的夜晚，Alice 坐下来玩经典的“连点成线”游戏，不过这次有些不同。

为了玩这个游戏，Alice 画了一条直线，并在上面标记了 𝑛 个点，编号从 1 到 𝑛。最初，这些点之间没有任何连接，所以它们都是独立的。在这之后，Alice 进行 𝑚 次以下类型的操作：

  • 她选择三个整数 𝑎 𝑖 𝑎_𝑖 ai​、 𝑑 𝑖 𝑑_𝑖 di​（1≤ d 𝑖 d_𝑖 di​≤10）和 𝑘 𝑖 𝑘_𝑖 ki​。
  • 她选择点 𝑎 𝑖 𝑎_𝑖 ai​、 𝑎 𝑖 + 𝑑 𝑖 𝑎_𝑖+𝑑_𝑖 ai​+di​、 𝑎 𝑖 + 2 𝑑 𝑖 𝑎_𝑖+2𝑑_𝑖 ai​+2di​、 𝑎 𝑖 + 3 𝑑 𝑖 𝑎_𝑖+3𝑑_𝑖 ai​+3di​,…, 𝑎 𝑖 + 𝑘 𝑖 ⋅ 𝑑 𝑖 𝑎_𝑖+𝑘_𝑖⋅𝑑_𝑖 ai​+ki​⋅di​，并将这些点之间两两相连。

在执行完所有 𝑚 次操作后，她想知道这些点形成了多少个连通分量。请帮她找到这个数量。

注释：如果两个点之间存在通过若干（可能为零）个连接点和其他点的路径，则它们属于同一个连通分量。

输入

每个测试包含多个测试用例。第一行包含测试用例的数量 𝑡 𝑡 t（1 ≤ 𝑡 𝑡 t ≤ 10⁵）。每个测试用例的描述如下。

每个测试用例的第一行包含两个整数 𝑛 𝑛 n 和 𝑚 𝑚 m（1 ≤ 𝑛 𝑛 n ≤ 2⋅10⁵, 1 ≤ 𝑚 𝑚 m ≤ 2⋅10⁵）。

接下来的 𝑚 𝑚 m 行中，第 𝑖 𝑖 i 行包含三个整数 𝑎 𝑖 𝑎_𝑖 ai​、 𝑑 𝑖 𝑑_𝑖 di​ 和 𝑘 𝑖 𝑘_𝑖 ki​（1 ≤ 𝑎 𝑖 𝑎_𝑖 ai​ ≤ 𝑎 𝑖 + 𝑘 𝑖 ⋅ 𝑑 𝑖 𝑎_𝑖 + 𝑘_𝑖⋅𝑑_𝑖 ai​+ki​⋅di​ ≤ 𝑛, 1 ≤ 𝑑 𝑖 𝑑_𝑖 di​ ≤ 10, 0 ≤ 𝑘 𝑖 𝑘_𝑖 ki​ ≤ 𝑛）。

保证所有测试用例中 𝑛 𝑛 n 和 𝑚 𝑚 m 的总和不超过 2 ⋅ 1 0 5 2⋅10⁵ 2⋅105。

输出

对于每个测试用例，输出连通分量的数量。

示例

输入

3
10 2
1 2 4
2 2 4
100 1
19 2 4
100 3
1 2 5
7 2 6
17 2 31

输出

2
96
61

说明

在第一个测试用例中，有 𝑛 𝑛 n = 10 个点。第一次操作连接了点 1、3、5、7 和 9。第二次操作连接了点 2、4、6、8 和 10。因此，有两个连通分量：{1,3,5,7,9} 和 {2,4,6,8,10}。

在第二个测试用例中，有 𝑛 𝑛 n = 100 个点。唯一的操作连接了点 19、21、23、25 和 27。它们形成了一个大小为 5 的连通分量。其余的 95 个点形成了单点连通分量。因此，答案是 1+95=96。

在第三个测试用例中，有 𝑛 𝑛 n = 100 个点。经过这些操作，所有从 1 到 79 的奇数点将会形成一个大小为 40 的连通分量。其余的 60 个点形成了单点连通分量。因此，答案是 1+60=61。

一、问题分析

很明了，就是要求连通分量的个数，一下子就能想到并查集，统计相异父节点的个数，得到答案。

import java.util.Scanner;
 
public class Main {
    public static int find(int x, int[] father){
        if(father[x] != x){
            father[x] = find(father[x], father);
        }
        return father[x];
    }
    public static void join(int x, int y, int[] father){
        int rootX = find(x, father);
        int rootY = find(y, father);
        if(rootX != rootY){
            father[rootX] = rootY;
        }
    }
    public static int solution(int n, int m, int[][] op) {
        // 有 1 到 n 个点；m 个操作，返回最后的连通分量的个数
        int[] father = new int[n + 1];
        // 初始化并查集
        for(int i = 1; i <= n; i++){
            father[i] = i;
        }
        for(int i = 0; i < m; i++){
            int a = op[i][0];
            int d = op[i][1];
            int k = op[i][2];
            for(int j = 1; j <= k; j++){
                join(a, a + j*d, father);
            }
        }
        int cnt = 0;
        // 统计连通分量的个数
        for(int i = 1; i <= n; i++){
            if(father[i] == i){
                cnt++;
            }
        }
        return cnt;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int cnt = scanner.nextInt(); // Number of test cases
        while (cnt-- > 0) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[][] op = new int[m][3];
            for(int i = 0; i < m; i++){
                int a = scanner.nextInt();
                int d = scanner.nextInt();
                int k = scanner.nextInt();
                op[i][0] = a;
                op[i][1] = d;
                op[i][2] = k;
            }
            System.out.println(solution(n, m, op));
        }
        scanner.close();
    }
}

提交答案，结果超时了！
在这里插入图片描述
让我们分析一下时间复杂度，复杂度主要是下面的代码造成的，时间复杂度： O ( n + m ∗ k ) O(n + m*k ) O(n+m∗k)

  1. join函数复杂度：并查集的 j o i n join join 操作的时间复杂度一开始为 O ( l o g ( n ) ) O(log(n)) O(log(n))，随着节点的增加趋近于 O ( 1 ) O(1) O(1) 。
        // 初始化并查集
        for(int i = 1; i <= n; i++){
            father[i] = i;
        }
        for(int i = 0; i < m; i++){
            int a = op[i][0];
            int d = op[i][1];
            int k = op[i][2];
            for(int j = 1; j <= k; j++){
                join(a, a + j*d, father);
            }
        }
  1. 操作中的循环：在每次操作中，通过 join 函数连接多个节点（k 次），这会随着 k 值的增加带来较大的复杂度。如果 k 和 d 较大，单次操作的复杂度会非常高。主要就是连接 a a a 和 a + d , a + 2 d , a + 3 d , . . . , a + k d a + d, a + 2d, a + 3d, ..., a + kd a+d,a+2d,a+3d,...,a+kd，更新父节点造成严重的时间复杂度。
 for(int j = 1; j <= k; j++){
      join(a, a + j*d, father, rank);
  }

二、优化代码

使用动态规划算法，用空间换时间。时间复杂度： O ( 10 ∗ n + m ) O(10*n + m) O(10∗n+m)

import java.util.Scanner;

public class Main {
    public final static int N = 200002;
    public final static int C = 11;

    public static int find(int x, int[] father) {
        if (father[x] != x) {
            father[x] = find(father[x], father);
        }
        return father[x];
    }

    public static void join(int x, int y, int[] father) {
        int rootX = find(x, father);
        int rootY = find(y, father);
        if (rootX != rootY) {
            father[rootX] = rootY; // 将 rootY 连接到 rootX
        }
    }

    public static int solution(int n, int m, int[][] op) {
        // 有 1 到 n 个点；m 个操作，返回最后的连通分量的个数
        int[] father = new int[n + 1];
        // dp[i][j] 表示以 i 为起点，公差为 j 的等差数列的长度
        int[][] dp = new int[n + 1][C];
        // ind[i][j] 表示以 i 为起点，公差为 j 的等差数列的终点
        int[][] ind = new int[n + 1][C];
        // start_cnt[i][j] 表示以 i 为起点，公差为 j 的等差数列的个数
        int[][] start_cnt = new int[n + 1][C];
        // end_cnt[i][j] 表示以 i 为终点，公差为 j 的等差数列的个数
        int[][] end_cnt = new int[n + 1][C];

        // 初始化并查集
        init(n, father, dp, ind, start_cnt, end_cnt, C);
        // 遍历操作
        for (int i = 0; i < m; i++) {
            int a = op[i][0];
            int d = op[i][1];
            int k = op[i][2];
            // 以 a 为起点，公差为 d 的等差数列的个数加一
            start_cnt[a][d]++;
            if (a + k * d < N) {
                // 以 a + k * d 为终点，公差为 d 的等差数列的个数加一
                end_cnt[a + k * d][d]++;
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j < C; j++) {
                // 计算以 i 为起点，公差为 j 的等差数列的长度
                dp[i][j] = start_cnt[i][j] - end_cnt[i][j];
                // 如果 i - j < 1，跳过
                /**
                 * 这段逻辑用于跳过那些会导致数组下标越界的情况。
                 * 具体来说，当 `i - j < 1` 时，`dp[i - j][j]` 会访问负数或零的下标，
                 * 这是不合法的数组访问。因此，跳过这些情况可以避免运行时错误。
                 */
                if (i - j < 1) {
                    continue;
                }
                // 如果 dp[i - j][j] > 0，合并两个等差数列
                if (dp[i - j][j] > 0) {
                    // 合并两个等差数列
                    join(ind[i - j][j], i, father);
                    // 更新终点
                    ind[i][j] = ind[i - j][j];
                    // 更新长度
                    dp[i][j] += dp[i - j][j];
                }
            }
        }
        int cnt = 0;
        // 统计连通分量的个数
        for (int i = 1; i <= n; i++) {
            if (father[i] == i) {
                cnt++;
            }
        }
        return cnt;
    }

    public static void init(int n, int[] father, int[][] dp, int[][] ind, int[][] start_cnt, int[][] end_cnt, int c) {
        for (int i = 1; i <= n; i++) {
            father[i] = i;
            for (int j = 1; j < c; j++) {
                dp[i][j] = start_cnt[i][j] = end_cnt[i][j] = 0;
                ind[i][j] = i;
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int cnt = scanner.nextInt(); // Number of test cases
        while (cnt-- > 0) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[][] op = new int[m][3];
            for (int i = 0; i < m; i++) {
                int a = scanner.nextInt();
                int d = scanner.nextInt();
                int k = scanner.nextInt();
                op[i][0] = a;
                op[i][1] = d;
                op[i][2] = k;
            }
            System.out.println(solution(n, m, op));
        }
        scanner.close();

    }
}

提交结果

在这里插入图片描述

三、进一步优化

并查集路径压缩与按秩/大小合并的优化：当前实现中只有路径压缩，而没有按秩/大小合并（union by rank 或者 union by size），这可能导致在某些情况下，树的高度较大，影响性能。

1. 按秩合并（Union by Rank）

通过在 join 时优先将小集合合并到大集合，可以有效减少树的高度，提升查找的效率。

2. 按大小合并（Union by Size）

倾向于将节点较少的树合并到节点较多的树上，而不是严格按照高度。但在许多实际应用中，这两种方法的性能差异通常不大，尤其是当它们与路径压缩一起使用时。

优化说明：

  1. 按秩合并（rank[] 数组）：在合并过程中，通过维护每个集合的秩来选择将较小的树连接到较大的树，从而有效降低树的高度。

这个优化可以显著提高代码的运行效率，特别是对于大规模输入时。

import java.util.Scanner;

public class Main {
    public final static int N = 200002;
    public final static int C = 11;

    public static int find(int x, int[] father) {
        if (father[x] != x) {
            father[x] = find(father[x], father);
        }
        return father[x];
    }

    public static void join(int x, int y, int[] father, int[] rank) {
        int rootX = find(x, father);
        int rootY = find(y, father);
        if (rootX != rootY) {
            // 按秩合并
            if (rank[rootX] > rank[rootY]) {
                father[rootY] = rootX; // 将 rootY 连接到 rootX
            } else if (rank[rootX] < rank[rootY]) {
                father[rootX] = rootY; // 将 rootX 连接到 rootY
            } else {
                father[rootY] = rootX; // 将 rootY 连接到 rootX
                rank[rootX]++; // 树的高度增加
            }

        }
    }

    public static int solution(int n, int m, int[][] op) {
        // 有 1 到 n 个点；m 个操作，返回最后的连通分量的个数
        int[] father = new int[n + 1];
        int[] rank = new int[n + 1];
        // dp[i][j] 表示以 i 为起点，公差为 j 的等差数列的长度
        int[][] dp = new int[n + 1][C];
        // ind[i][j] 表示以 i 为起点，公差为 j 的等差数列的终点
        int[][] ind = new int[n + 1][C];
        // start_cnt[i][j] 表示以 i 为起点，公差为 j 的等差数列的个数
        int[][] start_cnt = new int[n + 1][C];
        // end_cnt[i][j] 表示以 i 为终点，公差为 j 的等差数列的个数
        int[][] end_cnt = new int[n + 1][C];

        // 初始化并查集
        init(n, father, rank, dp, ind, start_cnt, end_cnt, C);
        // 遍历操作
        for (int i = 0; i < m; i++) {
            int a = op[i][0];
            int d = op[i][1];
            int k = op[i][2];
            // 以 a 为起点，公差为 d 的等差数列的个数加一
            start_cnt[a][d]++;
            if (a + k * d < N) {
                // 以 a + k * d 为终点，公差为 d 的等差数列的个数加一
                end_cnt[a + k * d][d]++;
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j < C; j++) {
                // 计算以 i 为起点，公差为 j 的等差数列的长度
                dp[i][j] = start_cnt[i][j] - end_cnt[i][j];
                // 如果 i - j < 1，跳过
                /**
                 * 这段逻辑用于跳过那些会导致数组下标越界的情况。
                 * 具体来说，当 `i - j < 1` 时，`dp[i - j][j]` 会访问负数或零的下标，
                 * 这是不合法的数组访问。因此，跳过这些情况可以避免运行时错误。
                 */
                if (i - j < 1) {
                    continue;
                }
                // 如果 dp[i - j][j] > 0，合并两个等差数列
                if (dp[i - j][j] > 0) {
                    // 合并两个等差数列
                    join(ind[i - j][j], i, father, rank);
                    // 更新终点
                    ind[i][j] = ind[i - j][j];
                    // 更新长度
                    dp[i][j] += dp[i - j][j];
                }
            }
        }
        int cnt = 0;
        // 统计连通分量的个数
        for (int i = 1; i <= n; i++) {
            if (father[i] == i) {
                cnt++;
            }
        }
        return cnt;
    }

    public static void init(int n, int[] father, int[] rank, int[][] dp, int[][] ind, int[][] start_cnt, int[][] end_cnt, int c) {
        for (int i = 1; i <= n; i++) {
            father[i] = i;
            rank[i] = 1;
            for (int j = 1; j < c; j++) {
                dp[i][j] = start_cnt[i][j] = end_cnt[i][j] = 0;
                ind[i][j] = i;
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int cnt = scanner.nextInt(); // Number of test cases
        while (cnt-- > 0) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[][] op = new int[m][3];
            for (int i = 0; i < m; i++) {
                int a = scanner.nextInt();
                int d = scanner.nextInt();
                int k = scanner.nextInt();
                op[i][0] = a;
                op[i][1] = d;
                op[i][2] = k;
            }
            System.out.println(solution(n, m, op));
        }
        scanner.close();

    }
}

提交结果

在这里插入图片描述

四、总结

感觉本题动态规划还是蛮难想到的，挺有意思的一道题。

汉丽轩
关注
codeforces round 962 (div. 3).docx
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
codeforces round 962 (div. 3) .zip
07-28
Codeforces Round 962 (Div. 3) 是一场编程竞赛，旨在测试参赛者在算法和数据结构方面的能力。由于篇幅限制，我将对这场竞赛中的几个关键问题进行详细解析，但请注意，由于具体实现细节可能因题目而异，且无法在此...
Codeforces Round 976 (Div. 2) and Divide By Zero 9.0（A~E）
weixin_61825750的博客
09-30 1418
上分中
Codeforces Round 975 (Div. 2) A-C 题解
AKDreamer_HeXY的博客
09-29 1227
这次看到 C 题分数 1750 就开始害怕了，用小号打的比赛，一直觉得做不出来，最后才想到。
Codeforces Round 946 (Div. 3)
gege_0606的博客
05-21 1886
З手机桌面- A - Codeforces。
Codeforces Round 972（Div.2）A+B
YGGP的博客
09-16 858
Codeforces Round 972（Div.2）A+B
Codeforces Round 973 (Div. 2)
2301_79929720的博客
09-21 966
Codeforces Round 973 (Div. 2)
Codeforces Round 950 (Div. 3)（A~F2）
weixin_61825750的博客
06-04 2047
G题只会暴力..不会数据结构暴力模拟即可。
Codeforces Round 968 (Div. 2)
HKUST_ZJH的博客
08-28 1325
Codeforces Round 968 (Div. 2)
Codeforces Round 944 (Div. 4)
maisui12138的博客
05-11 1046
思路：可以发现，二进制下第一和第二位00,01，10,11的任何排列组合都是符合条件的，所以可以交换的元素除了首位和次位的二进制一定是相等的，我们存储这样相同的元素进行排列，按顺序输出即可；有0到n个站点，汽车从站点0开始行驶，已知汽车到达其中k个站点的时间，这k个站点之间的平均速度是相同的，即a1点到a2点为一个。二分查询时第一个大于当前查询点的l点，当前点的时间即为l-1点的时间 + l-1到l之间经过点的和；题意：在n个非负整数的序列a中，可以任意交换两两异或值小于4的元素，求可能的最小字典序数组；
Codeforces Round 961 (Div. 2)（A~D)
weixin_61825750的博客
07-24 1450
因此我们对于每一个位置，只需要将最大的那个集合设为不可选，然后最终将大集合中的所有小集合同步更新即可。枚金币买尽可能多的价格少的那一种花，然后再用剩下的钱买尽可能多的价格多的那一种花。因此我们只需要从后往前遍历所有位置，然后统计哪些集合是没法选的，最终在剩下的集合中选一个所含字母最少的即可。，接下来我们只需要求最多可以执行多少次这样的操作即可，然后便可以求出最大的花瓣数。然后，我们可以通过放弃价格少的一种花，再购买价格多的那一种花，使得所得到的花瓣加。贪心，先将占有单元格最多的对角线填满，然后依次往下填。
Codeforces Round 943 (Div. 3) 题解 （全）
2301_80105412的博客
05-03 2131
Codeforces Round 943 (Div. 3) 题解
codeforces round 961 (div. 2)
07-25
### Codeforces Round 961 (Div. 2) A题解析 #### 题目背景 Codeforces Round 961 (Div. 2) 是一场针对中级水平程序员的编程竞赛，通常会包含几个不同难度级别的题目。A题作为入门级题目，旨在测试参赛者的基础算法...
Codeforces Round 964 (Div. 4).pdf
08-07
A~G
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 416
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 524
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1224
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 791
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 320
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
Codeforces Round 511 (Div. 1)
07-25
根据提供的引用内容，Codeforces Round 511 (Div. 1)是一个比赛的名称。然而，引用内容中没有提供与这个比赛相关的具体信息或问题。因此，我无法回答关于Codeforces Round 511 (Div. 1)的问题。如果您有关于这个比赛的具体问题，请提供更多的信息，我将尽力回答。 #### 引用[.reference_title] - *1* [Codeforces Round 860 (Div. 2)题解](https://blog.csdn.net/qq_60653991/article/details/129802687)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Codeforces Round 867 (Div. 3)（A题到E题）](https://blog.csdn.net/wdgkd/article/details/130370975)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [Codeforces Round 872 (Div. 2)（前三道](https://blog.csdn.net/qq_68286180/article/details/130570952)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值