用Python编程实现带有压缩规则和加权规则的Find和Union算法，写出主程序设置初始集合中只包含一个元素，随机执行union和find的方法，分别打印数组存储情况

以下是带有压缩规则和加权规则的Find和Union算法的Python实现：

class WeightedQuickUnion:
    def __init__(self, n):
        self.count = n
        self.parent = [i for i in range(n)]
        self.size = [1 for i in range(n)]

    def find(self, p):
        while p != self.parent[p]:
            self.parent[p] = self.parent[self.parent[p]]
            p = self.parent[p]
        return p

    def connected(self, p, q):
        return self.find(p) == self.find(q)

    def union(self, p, q):
        root_p = self.find(p)
        root_q = self.find(q)
        if root_p == root_q:
            return
        if self.size[root_p] < self.size[root_q]:
            self.parent[root_p] = root_q
            self.size[root_q] += self.size[root_p]
        else:
            self.parent[root_q] = root_p
            self.size[root_p] += self.size[root_q]
        self.count -= 1

这里使用了带有路径压缩和加权规则的算法，其中`parent`数组存储每个元素的根节点，`size`数组存储根节点所在的连通分量的大小。在`find`操作中，使用路径压缩方法将节点的父节点设为其根节点，以加速下一次查找。在`union`操作中，将小的连通分量合并到大的连通分量中，同时更新`size`数组和元素的根节点。

下面是主程序的实现：

import random

# 初始化集合
n = 10
uf = WeightedQuickUnion(n)

# 随机执行union和find操作
for i in range(n):
    p = random.randint(0, n-1)
    q = random.randint(0, n-1)
    if not uf.connected(p, q):
        uf.union(p, q)
        print(f"Union: {p} - {q}")
    else:
        print(f"Connected: {p} - {q}")

# 打印数组存储情况
print(uf.parent)

这里设置了初始集合中只包含一个元素，随机执行`union`和`find`操作，并在每次调用`union`方法时打印出操作的两个元素。最后打印`parent`数组，以展示元素的连通情况。