Weighted Quick Union with Path Compression (WQUPC)

在WQU基础上,添加一步路径压缩.

前面的优化都是在union,路径压缩是在find上面做文章.

这里的路径压缩我还没完全搞明白,之后不断再来的,不管是理解还是博文编排素材之类的.

说是加一步压缩是确实只在find里增加了一个步骤,而这里ALGS4官方又有两个版本,由于我现在没有把问题规模化,只是简单的实例化增加几个连接,

还不能很好的理解两者优劣,就都贴上来吧.

 class WeightedQuickUnion():
     __count = int()     #number of components
     __parent = list()   #__parent[i] parent of i
     __size = list()     #size[i] number of sites in subtree rooted at i
     #Each site is initially in its own component
     def __init__(self, N):
         self.__count = N
         for i in range(0, self.__count):
             self.__parent.append(i)
             self.__size.append(1)
     #Return the component identifier for the component containing site
     def find(self, p):
         self.validate(p)
         root = p
         #find root identifier
         while (root != self.__parent[root]):
             root = self.__parent[root]
         #merge the component containing site
         #***question:the loop ?
         while (p != root):
             newp = self.__parent[p]
             self.__parent[p] = root
             p = newp
         return p

     def connected(self, p, q):
         return self.find(p) == self.find(q)
     #Merges the component containig site p with
     #the component containing site q
     def union(self, p, q):
         rootP=self.find(p)
         rootQ=self.find(q)
         if (rootP == rootQ):
             return
         if (self.__size[rootP] < self.__size[rootQ]):
             self.__parent[rootP] = rootQ
             self.__size[rootQ] += self.__size[rootP]
         else:
             self.__parent[rootQ] = rootP
             self.__size[rootP] += self.__size[rootQ]
         self.__count-=1
     def validate(self, p):
         n = len(self.__parent)
         if (p < 0 or p >= n):
             raise ValueError("index", p, "is not between 0 and", (n - 1))
     def traversal(self):
         for i in self.__parent:
             print(i, end=' ')
 WQU = WeightedQuickUnion(12)
 WQU.union(0, 1)
 WQU.union(1, 2)
 WQU.union(3, 4)
 WQU.union(4, 5)
 WQU.union(5, 2)
 WQU.union(6, 7)
 WQU.union(7, 8)
 WQU.union(9, 10)
 WQU.union(10, 11)
 WQU.union(11, 8)
 WQU.union(11, 2)
 print(WQU.connected(2, 8))
 WQU.traversal()

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

上面单独给出了另一种写法,就是网课里面那么写的,课程可能是以前录制好的,多次播放.然后他们的程序不断更新了.

先出现的那种写法:

        root = p
        #find root identifier
        while (root != self.__parent[root]):
            root = self.__parent[root]

先找到根节点,

        while (p != root):
            newp = self.__parent[p]
            self.__parent[p] = root
            p = newp
        return p

(假设p不等于root)

然后先取出p的parent,然后把p的parent移接到根结点上,最后p赋值为p原先的parent也就是刚刚接到根结点的那个结点.

下一次迭代的时候p!=root,取出p的parent,这里已经取出root了,然后进行一次root赋值root冗余操作,最后p赋值为root,

再下一次迭代p==root,循环退出,返回p的root.

整个过程会移动p的parent位置,且一次性移动到根节点,循环会执行两次,第二次只是为了移动p的值,以便退出循环.

所查结点和其parent以及其grandparent会形成三层结构,(不考虑以当前结点为parent的结点,实际上这些结点会跟着移动位置的)

之后那种方法:

(也假设p!=root)

第一次p!=root,将p的panrent移动到p的grandparent,(当前循环次数的),p赋值为原p的grandparent.

假设第二次p!=root,(树很高:>)那么还会进行一次前面的操作,进一步压缩路径,可以看出中间会跳过一个结点

假设第三次p成为了root的直接后继,那么parent[p]和parent[parent[p]]都是取root的值,可以退出循环了.(下一次编辑一定会加上图的2333)

这个同上一种方法不同的是可能会移动很多次结点,如果树很高的话.

但是不用先迭代来寻找root.这两种方法都会修改结点位置,但是都已经破坏了其size,如不维护size,那么再union的时候就会出问题了.

还有不明白这个find会调用多少次?如果调用多次显然新版的程序更好,

之后肯定要写每次课程的作业,

记得视频中用蒙特卡洛方法计算percolation的概率,不去实现真的存在很多问题,现在