数据结构算法学习--并查集学习--java-python--(洛谷集合、天梯赛排位置、蓝桥杯修改数组 )

已于 2023-04-26 23:30:16 修改
阅读量268 收藏
点赞数
分类专栏： 算法 数据结构 文章标签： java python 数据结构
于 2023-04-21 09:29:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56717234/article/details/130274112
版权

文章目录

并查集介绍

主要用于解决一些元素分组的问题。它管理一系列不相交的集合。
主要包括2个操作：
合并（Union）：把两个不相交的集合合并为一个集合。
查询（Find）：查询两个元素是否在同一个集合中。

我们需要维护一个数组，每个数组元素指向和他同类型的元素的下标。

实现

这里我们用洛谷的一个模板题进行介绍
P3367 【模板】并查集
第一行包含两个整数 N,M ,表示共有 N 个元素和 M 个操作。
接下来 M 行，每行包含三个整数 Z i , X i , Y i ​ Z_ i ,X _i ,Y_ i​ Zi​,Xi​,Yi​​ ​
z=1 时，将x,y所在的集合合并时
z=2输出x,y是否在同一集合内，是的输出 Y ；否则输出 N 。

初始化

我们让所有的元素自己指向自己就可以了。我们最后判断是不是同一类，每一类就只有顶级父节点是指向自己的，后面有解释

# 初始化,让每一个元素的父节点都是自己
c = [i for i in range(n+1)]

查询操作

# 查找父节点
# 因为我们需要指向父节点下标
def find(x):
    global c
    while c[x] != x:
        x = c[x]
    return x

但是这样子，我们是会超时的，原因是如果一串联需要不断的向上查找，中间会浪费很多的时间。如1查询会一直2，3，4----。2查询会3，4—会有很多无用功。
1
2
3
4
5
...

所以我们进行路径压缩。

def find(x):
    global c
    y = x
    while c[x] != x:
        x = c[x]
    c[y] = x
    return x

合并

(先看代码)那么换一个顺序可以吗，其实都可以没关系，我们判断是否是同一个，那么其顶级父节点总会是指向自己的。

# 合并操作也是很简单的，先找到两个集合的代表元素
# 然后将前者的父节点设为后者即可。
def union(x,y):
    x = find(x)
    y = find(y)
    if x != y:
        c[y] = x

无论是3指向5，还是5指向3，另外一个都是指向自己的。
1
2
3
4
5

完整代码

java 用的递归，python不是。
评测结果是java更快。

import java.io.*;
import java.util.stream.IntStream;

public class Main {
    static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    static final PrintWriter print = new PrintWriter(System.out);


    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }
    static int[] pre;

    public static int find(int x){
        if (pre[x] == x)
            return x;
        else
            return pre[x] = find(pre[x]);
    }

    public static void union(int x, int y){
        x = find(x);
        y = find(y);
        if (x != y)
            pre[x] = y;
    }
    public static void init(int n){
        pre = IntStream.rangeClosed(0,n).toArray();
    }
    public static void main(String[] args) throws IOException {
        int n = nextInt();
        int m = nextInt();
        init(n);

        for (int i = 0; i < m; i++) {
            int z = nextInt();
            int x = nextInt();
            int y = nextInt();
            if (z == 1){
                union(x, y);
            }else{
                if (find(x) == find(y))
                    print.println("Y");
                else
                    print.println("N");
            }
        }
        print.flush();
    }



}

n, m = map(int, input().split())
# 初始化,让每一个元素的父节点都是自己
c = [i for i in range(n+1)]

# 查找父节点
def find(x):
    global c
    y = x
    while c[x] != x:
        x = c[x]
    c[y] = x
    return x
# 合并
def union(x,y):
    x = find(x)
    y = find(y)
    if x != y:
        c[y] = x
    
for _ in range(m):
    z,x,y = map(int, input().split())
    if z == 1:
        union(x, y)
    else:
        if find(x) == find(y):
            print("Y")
        else:
            print("N")

训练

洛谷P1621 集合

Caima 给你了所有 [a,b] 范围内的整数。一开始每个整数都属于各自的集合。每次你需要选择两个属于不同集合的整数，如果这两个整数拥有大于等于 p 的公共质因数，那么把它们所在的集合合并。
重复如上操作，直到没有可以合并的集合为止。
现在 Caima 想知道，最后有多少个集合。

思路：
是否同一集合我们使用并查集。
质因数我们使用埃式筛，

开始想的是先筛在并查，然后发现我们是可以在筛的过程中来进行合并的。
如:我们对 i i i质数进行筛选。 j j j为筛选的数，
那么，j和j-i一定有公共质因数i。
然后查询是否是同一集合

当然其中还得加上一些条件判断

import java.io.*;
import java.util.stream.IntStream;

public class Main {
    static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    static int[] pre;

    public static int find(int x) {
        if (pre[x] == x)
            return x;
        else
            return pre[x] = find(pre[x]);
    }

    public static void init(int b) {
        pre = IntStream.rangeClosed(0, b + 1).toArray();
    }


    public static void main(String[] args) throws IOException {
        int a = nextInt();
        int b = nextInt();
        int p = nextInt();
        init(b);
        // 每一个数都是一个集合
        int ans = b - a + 1;
        boolean[] f = new boolean[b + 1];
        for (int i = 2; i <= b; i++) {
            if (!f[i]) {
                if (i >= p) {
                    for (int j = i + i; j <= b; j += i) {
                        f[j] = true;
                        // 如果不同集合
                        if (j - i >= a && find(j) != find(j - i)) {
                            pre[find(j)] = find(j - i);
                            ans--;
                        }
                    }

                } else {
                    for (int j = i + i; j <= b; j += i) {
                        f[j] = true;
                    }
                }
            }
        }
        System.out.println(ans);
    }

}

天梯赛L2-010 排座位

在题目中需要知道朋友的朋友，那么我们就需要得到一个朋友圈。这个朋友圈呢，就等同于这个并查集。
而敌人呢，我们只需要知道他们是不是敌人就可以了，数组存储就可以了。

import java.io.*;
import java.util.stream.IntStream;

public class Main {
    static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static final PrintWriter print = new PrintWriter(new BufferedOutputStream(System.out));

    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    static int[] pre;

    public static int find(int x) {
        if (x == pre[x])
            return x;
        else
            return pre[x] = find(pre[x]);
    }

    public static void init(int n) {
        pre = IntStream.rangeClosed(0, n + 1).toArray();
    }

    public static void union(int x, int y) {
        x = find(x);
        y = find(y);
        if (x != y)
            pre[x] = y;
    }


    public static void main(String[] args) throws IOException {
        int n = nextInt();
        int m = nextInt();
        int k = nextInt();
        init(n);
        boolean[][] a = new boolean[n + 1][n + 1];
        for (int i = 0; i < m; i++) {
            int x = nextInt();
            int y = nextInt();
            int z = nextInt();
            if (z == 1) {
                union(x, y);
            } else {
                a[x][y] = true;
                a[y][x] = true;
            }
        }
        for (int i = 0; i < k; i++) {
            int x = nextInt();
            int y = nextInt();
            int x1 = find(x);
            int y1 = find(y);
            if (x1 == y1){
                if (a[x][y])
                    print.println("OK but...");
                else
                    print.println("No problem");
            }else{
                if (a[x][y])
                    print.println("No way");
                else
                    print.println("OK");
            }
        }
        print.flush();
    }
}

[蓝桥杯 2019 省 A] 修改数组

题目描述

给定一个长度为 N N N 的数组 A = [ A 1 , A 2 , ⋯ A N ] A=[A_1,A_2, \cdots A_N] A=[A1​,A2​,⋯AN​]，数组中有可能有重复出现的整数。

现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改 A 2 , A 3 , ⋯   , A N A_2,A_3, \cdots ,A_N A2​,A3​,⋯,AN​。

当修改 A i A_i Ai​ 时，小明会检查 A i A_i Ai​ 是否在 A 1 A_1 A1​ ∼ A i − 1 A_{i-1} Ai−1​ 中出现过。如果出现过，则小明会给 A i A_i Ai​ 加上 1 1 1；如果新的 A i A_i Ai​ 仍在之前出现过，小明会持续给 A i A_i Ai​ 加 1 1 1，直到 A i A_i Ai​ 没有在 A 1 A_1 A1​ ∼ A i − 1 A_{i-1} Ai−1​ 中出现过。

当 A N A_N AN​ 也经过上述修改之后，显然 A A A 数组中就没有重复的整数了。

现在给定初始的 A A A 数组，请你计算出最终的 A A A 数组。

输入格式

第一行包含一个整数 N N N。

第二行包含 N N N 个整数 A 1 , A 2 , ⋯   , A N A_1,A_2, \cdots ,A_N A1​,A2​,⋯,AN​。

输出格式

输出 N N N 个整数，依次是最终的 A 1 , A 2 , ⋯   , A N A_1,A_2, \cdots ,A_N A1​,A2​,⋯,AN​。

样例 #1

样例输入 #1

5
2 1 1 3 4

样例输出 #1

2 1 3 4 5

提示

对于 80 % 80\% 80% 的评测用例， 1 ≤ N ≤ 10000 1 \le N \le 10000 1≤N≤10000。

对于所有评测用例， 1 ≤ N ≤ 1 0 5 1 \le N \le 10^5 1≤N≤105， 1 ≤ A i ≤ 1 0 6 1 \le A_i \le 10^6 1≤Ai​≤106。

蓝桥杯 2019 年省赛 A 组 H 题。

思路

这个开始是用暴力的，但是最后2个超时了。
然后我就想emm，这个好像是需要找到最顶端的元素，这个思想特别想并查集的。然后用这个试，就ok了。

代码

import java.io.*;
import java.util.Arrays;

public class Main {
    static final PrintWriter print = new PrintWriter(System.out);
    // 更快的输入输出
    static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }
    //存放每一个数的最大的数
    static int[] a = new int[1000000];

    //
    public static int find(int x) {
        if (a[x] == x) {
            a[x] = x + 1;
            return x;
        }
        return a[x] = find(a[x]);
    }

    public static void main(String[] args) throws IOException {
        int n = nextInt();
        int[] b = new int[n];
        for (int i = 0; i < n; i++) {
            b[i] = nextInt();
        }
        a[0] = 0;
        Arrays.parallelPrefix(a, (x, y) -> x + 1);
        a[b[0]] = b[0] + 1;
        for (int i = 1; i < n; i++) {
            b[i] = find(b[i]);
        }
        print.print(b[0]);
        for (int i = 1; i < n; i++) {
            print.print(" " + b[i]);
        }
        print.flush();
    }

}
一只小余
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只小余

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

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

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

打赏作者

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

抵扣说明：

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

余额充值