蓝桥杯-并查集的运用（二）

写在前面：越是刷题，越发现自己不会的越多，现在的思路是把之前学过的知识点复习一下，把刷过的题重新过一遍，避免犯同样的错误

题目一 国王的烦恼

这是一道值得学习的题目，整体的框架还是并查集，但在并查集的基础上，比较偏重于对思维的考验，这道题目运用到了反向思维，能想明白就很简单

题目链接

题目描述

C国由n个小岛组成，为了方便小岛之间联络，C国在小岛间建立了m座大桥，每座大桥连接两座小岛。两个小岛间可能存在多座桥连接。然而，由于海水冲刷，有一些大桥面临着不能使用的危险。

如果两个小岛间的所有大桥都不能使用，则这两座小岛就不能直接到达了。然而，只要这两座小岛的居民能通过其他的桥或者其他的小岛互相到达，他们就会安然无事。但是，如果前一天两个小岛之间还有方法可以到达，后一天却不能到达了，居民们就会一起抗议。

现在C国的国王已经知道了每座桥能使用的天数，超过这个天数就不能使用了。现在他想知道居民们会有多少天进行抗议。

下文中的样例说明
第一天后2和3之间的桥不能使用，不影响。
第二天后1和2之间，以及1和3之间的桥不能使用，居民们会抗议。
第三天后3和4之间的桥不能使用，居民们会抗议。



输入

输入的第一行包含两个整数n, m，分别表示小岛的个数和桥的数量。 

接下来m行，每行三个整数a, b, t，分别表示该座桥连接a号和b号两个小岛，能使用t天。小岛的编号从1开始递增。



数据规模和约定
对于100%的数据，1< =n< =10000，1< =m< =100000，1< =a, b< =n， 1< =t< =100000。

输出

输出一个整数，表示居民们会抗议的天数。

样例输入


4 4
1 2 2
1 3 2
2 3 1
3 4 3


样例输出


2

思路：所有的桥都会被冲掉，那么反过来想，我们先对桥的保存时间排一个序（降序），依次添加两个桥到并查集中

• 如果两个元素没有相同的根节点，那么这座桥被冲毁之后，居民会抗议，如果两个元素有相同的根节点，那么这两个点之前存在路径，居民不会抗议

• 存在同一天有多座桥被冲毁的情况，这里只算一天，所以计数的时候，要加上这个条件

def find(L, x):
    if L[x] != x:
        L[x] = find(L, L[x])
    return L[x]
def merge(L, x, y):
    x_root = find(L, x)
    y_root = find(L, y)
    if (x_root != y_root):
        L[x_root] = y_root
        return True
    else:
        return False

n, m = map(int, input().split())
L = [i for i in range(n + 1)]
M = []
for i in range(m):
    M.append(tuple(list(map(int, input().split()))))
#print(M)
M.sort(key = lambda L : L[2], reverse = True)
print(M)
count = 0
t = M[0][2] + 1
#为什么时间要加一，这个地方需要好好理解
for A in M:
    if merge(L, A[0], A[1]) and t != A[2]:
        count += 1
        t = A[2]
print(count)

题目二 蓝桥幼儿园

1、题目描述
蓝桥幼儿园的学生是如此的天真无邪，以至于对他们来说，朋友的朋友就是自己的朋友。

小明是蓝桥幼儿园的老师，这天他决定为学生们举办一个交友活动，活动规则如下：

小明会用红绳连接两名学生，被连中的两个学生将成为朋友。

小明想让所有学生都互相成为朋友，但是蓝桥幼儿园的学生实在太多了，他无法用肉眼判断某两个学生是否为朋友。于是他起来了作为编程大师的你，请你帮忙写程序判断某两个学生是否为朋友（默认自己和自己也是朋友）

2、输入描述

输出描述
对于每个op=2的输入，如果z和y是朋友，则输出一行YES，否则输出一行NO。

输入输出样例
输入：

5 5 
2 1 2
1 1 3
2 1 3
1 2 3 
2 1 2
1
2
3
4
5
6
输出：

NO
YES
YES

解题思路：简单的模板题

"""
测试样例
5 5 
2 1 2
1 1 3
2 1 3
1 2 3 
2 1 2
"""

n, m = map(int, input().split())
L = [i for i in range(n + 1)]
def find(L, x):
    if L[x] == x:
        return L[x]
    else:
        L[x] = find(L, L[x])
        return L[x]
def merge(L, x, y):
    x_root = find(L, x)
    y_root = find(L, y)
    L[x_root] = y_root

for i in range(m):
    op, x, y = map(int, input().split())
    if op == 1:
        merge(L, x, y)
    else:
        if find(L, x) == find(L, y):
            print("YES")
        else:
            print("NO")

题目三 城邦

解题思路：

• 怎么计算装饰一座桥的花费 cost函数实现

• 从哪座桥开始装饰 sort函数排序

• 什么时候停止 count 计数，连接2021一座城邦，只需要2020座桥

解题代码

def cost(x, y):
    S = 0
    while x or y:
        if x % 10 != y % 10:
            S = S + x % 10 + y % 10
        x = x // 10
        y = y // 10
    return S
def find(L, x):
    if L[x] != x:
        L[x] = find(L, L[x])
    return L[x]
def merge(L, x, y):
    if find(L, x) != find(L, y):
        L[find(L, x)] = find(L, y)

M = [(i, j, cost(i, j)) for i in range(1, 2022) for j in range(1, 2022)]
#M的初始化，应该从1到2021，这样排序完才是准确的；
# j可以从1开始，因为合并的时候已经有路径的不会合并
M.sort(key = lambda L: L[2])
#lambda函数的用法要熟悉
L = [i for i in range(2022)]
ans = 0
count = 0
for A in M:
    if find(L, A[0]) != find(L, A[1]):
        merge(L, A[0], A[1])
        ans += A[2]
        count += 1
    if count == 2020:
        break
print(ans)