跟着Sedgewick学算法(week 1 UnionFind)

发现笔记转过来，没有图的~~~~~~~~~~~悲剧，给出共享笔记链接

https://www.evernote.com/pub/yanbinliu/algorithm

很久之前就在coursera看到Robert的算法课程，当时太懒惰，没有跟着学习。前两天逛coursera偶然发现又开课了，于是毫不犹豫跟着

走起。

基本上每一个课程开始，总会有introduction blabla之类的。Robert的算法课程，上来不到10分钟的欢迎致辞，然后就直接从一个例子讲起，来分析一个问题。

建模，找到算法求解，找不足，改进，迭代直到满意为止。

首先给出的问题是dynamic connectivity，动态连通问题，就是给出譬如

（1，2）

（7，3）

（4，9）

……

等连接在一起的点对，

然后判断，一对（p，q）之间是否存在连通路径。

为了解决这个问题，主要分为两步：

1.将给出的点对连接起来，即Union的过程

2.判断一个对点（p，q）之间是否有连通路径

一个比较直观的应用就是迷宫…………，不过当然不止如此，譬如数字图像，网路，电路等等。

为了简化问题，忽略其他无关因素，只考虑0-9这10个数字。

---

首先，给出的分析quick find

顾名思义，可知这种算法，可以快速判断两个点是否连接。

采用长度为10的数组，数组索引标识点自身，数组值表示与其数组索引连接的点，

 

如图所示，0，5，6是连通的，1，2，7也是连通的。

某大牛说，算法+数据结构=程序，其实很大程度上有些问题，一旦给出了数据结构，算法就水到渠成了的，虽然这里是个很小的问题。

下面就是简单的c#代码

 

 public class QuickFind

    {

        public List< int> list;

        public QuickFind( int n)

        {

            list = new List< int>(n);

            for ( int i = 0; i < n; i++)

            {

                list.Add(i);

            }

        }

        public void AddUnion( int p, int q)

        {

            var pid = list[p];

            var qid = list[q];

            for ( int i = 0; i < list.Count(); i++)

            {

                if (list[i] == pid) list[i] = qid;

            }

        }

        public bool Connected( int p, int q)

        {

            return list[p] == list[q];

        }

        public void writeResult()

        {

            foreach ( var item in list)

            {

                Console.Write(item.ToString()+ ' ');

            }

        }

 

    }

 

提出了算法，就要简单分析一下复杂度之类的，blabla的，如下图

 

对于find来讲，复杂度很低，只要O（1）就行，每次只是需要比较两个索引点的值就行，

但是对于union的动作就有点高了，对于N个点对来实现union命令，复杂度是O(N^2)(N的平方）。

---

 

接下来分析quick union 算法

同时是以数组作为数据结构，只不过每个索引点中的值是该点的父节点，知道索引值等于存储值为止，最终的节点就是root节点，上图比较容易懂

3的root是9，root节点相同的，就是连通的。

自然而然就可以得到简单的代码实现

 

 

 

public class QuickUnion

    {

        int[] list;

        public QuickUnion( int n)

        {

             list = new  int[n];

            for ( int i = 0; i < n; i++)

            {             

                list[i]=i;

            }

        }

        public bool Find( int p, int q)

        {

            return root(p) == root(q);

        }

        public void AddUnion( int p, int q)

        {

            int i = root(p);

            int j = root(q);

            if (i == j) return;

            list[i]=j;

        }

        private int root( int p)

        {

            while (p != list[p])

            {        

                p = list[p];

            }

            return p;

        }

        public void writeResult()

        {

            for ( int i = 0; i < list.Count(); i++)

            {

                Console.Write(list[i].ToString()+ ' ');

            }

        }

    }

算法复杂都分析如上图。

quick-find的缺点是union动作代价太高，虽然保持了形成的树是flat的，但是为了保持flat代价太高

quick-union的缺点是形成的树太高，而且find操作代价高

 

---

当然了，有了解决方案，但是效果不理想，下一步想的就是怎么improvement了~~

 

 

Improvement 1

 

 

改进一：利用weighted quick-union，即在每次union的时候，将size比较小的树的根指向size较大的树的根，

而不是反过来。这里size大小指的是每个树的节点的多少，而不是树的高度（当然也可以是，只不过节点数比较好计算）。

 

 

这当然是一个挺好的改进，不过让我想到空间和时间的不可完美统一。虽然时间上改进了，但是空间上需要多出一个size数组来保持树的大小，所以凡事没有完美的~~

 

下图是一个100个sites，88个union操作得出的结果，weiggted算法效果还是很显著的

 

 

代码如下

 

 

public class WeightedQuickUnion

    {

        int[] list;

        int[] size;

        public WeightedQuickUnion( int n)

        {

             list = new  int[n];

             size = new int[n];

            for ( int i = 0; i < n; i++)

            {

              

                list[i]=i;

                size[i]=1;

            }

        }

        public bool Find( int p, int q)

        {

            return root(p) == root(q);

        }

        public void AddUnion( int p, int q)

        {

            int i = root(p);

            int j = root(q);

            if (i == j) return;

            if(size[i] < size[j])

            {

                list[i] = j;

                size[j] += size[i];

            }

            else

            {

                list[j] = list[i];

                size[i] += size[j];

            }

        }

        private int root( int p)

        {

            while (p != list[p])

            {

                p = list[p];

            }

            return p;

        }

        public void writeResult()

        {

            for ( int i = 0; i < list.Count(); i++)

            {

                Console.Write(list[i].ToString()+ ' ');

            }

        }

    }

简单分析下：

     find操作需要判断节点的root是否一致，所以和节点的深度相关

     union操作在给定节点root的情况下，是话费常量时间的。

然而，具有N个节点的weighted quick-union树的深度是不大于lgN的（2为底的）。

 

pf：

 

 

 

复杂度分析，就此我们得到满意答案了吗？

 

Of  Course NOT！！

 

 

Improvement 2：path compression

 

即quick-union with path compression，

对一个一个节点p，直接将其父节点设为root节点，那就是极好的了。

 

 

 

 

 

这几幅图，可以很好的展现出算法的实现原理。但是，但是，但是，这只需要添加一句代码就ok的啊，竟然只要一句的

 private int root(int p)

        {

            while (p != list[p])

            {

                list[p] = list[list[p]];//添加这一句

                p = list[p];

            }

            return p;

        }

一句话：No reason not to！

 

不可否认啊，效果好的算法一般分析起来，就没那么看起来简单了~~amortized analysis

 

[Hopcroft-Ulman,Tarjan] Starting from an empty data structure, any sequence of M 

union-find ops on N objects makes ≤ c ( N+ Mlg* N)array accesses

 

简单的算法，优雅的数学~~

 

但是，又是但是，每次都会有但是

虽然在实践中，WQUPC是线性的，但是理论确不是，甚至理论上不存在理论的算法。

 

复杂度分析大阅兵

 

10^9个union和find对10^9节点，WQUPC可以将时间从30年降到6s~~这就是算法的强大

~~

 

 

---

最后的最后，一个实践。

渗透概率问题，

 

对于一个节点是否open的概率p，与是否渗透的概率之间有什么关系~~

如图

over~~