lintcode178. graph valid tree 图是否是树

【题目】

给出 n 个节点，标号分别从 0 到 n - 1 并且给出一个 无向 边的列表 (给出每条边的两个顶点), 写一个函数去判断这张｀无向｀图是否是一棵树

假设我们不会给出重复的边在边的列表当中. 无向边　[0, 1] 和 [1, 0]　是同一条边， 因此他们不会同时出现在我们给你的边的列表当中。

Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree.

【样例】

给出n = 5 并且 edges = [[0, 1], [0, 2], [0, 3], [1, 4]], 返回 true.

给出n = 5 并且 edges = [[0, 1], [1, 2], [2, 3], [1, 3], [1, 4]], 返回 false.

【解题思路】

1.      如果图中边的个数不等于点的个数n-1，必然不为树

2.      如果有边的两个点属于同一个子树，则这个图不为树。

 如何判断两个点是否属于同一个子树？

将有连边的两个点放在同一集合中(高大上的并查集)。可以使用长度为n的一维数组existed表示点之间的关系，existed初始化为-1。对于每条边连接的两个点，通过判断两个点在existed数组中的值判断点是否在图中出现过，点所属的集合，并进行处理。

1.      如果两个点处的值均为-1，表示两个点都没出现过，将两个点在existed中的值置为较小的点，表示两个点所在的集合；

2.      如果一个点在图中出现过，一个点未出现过，将未出现过的点在existed中对应的值置为已出现过的点对应的值，相当于更新了点的集合；

3.      如果两个点都出现过，合并两个点所在集合，将两个集合中点在existed中对应的值都换为值较小的集合。

4.      如果两个点属于同一个集合，图不为树。

AC代码如下（64ms）

class Solution {public:    /**     * @param n an integer     * @param edges a list of undirected edges     * @return true if it's a valid tree, or false     */    bool validTree(int n, vector<vector<int>>& edges) {        // Write your code here        //使用n维向量保存某个点是否出现在图中，遍历edges，将有连边的点放入一个集合，如果两个点都已经在一个集合中，返回false，existed记录点是否已经存在在图中        //如果边的个数大于点的个数，返回false        if (n - edges.size() != 1)            return false;        //属于同一个集合的点都用数值小的点标识集合        vector<int> existed(n, -1);        for (int i = 0; i < edges.size(); ++i) {            int node1 = edges[i][0];            int node2 = edges[i][1];            //两个点属于同一集合            if (existed[node1] == existed[node2]) {                if (existed[node1] == -1)                    //都未出现过，更新existed                    existed[node1] = existed[node2] = min(node1, node2);                else                    return false;            } else {                //两个点都出现过，合并点所在集合                if (existed[node1] != -1 && existed[node2] != -1) {                    int min = existed[node1];                    int max = existed[node2];                    if (existed[node1] > existed[node2])                        swap(min, max);                    //将两个集合合并                    for (int j = 0; j < n; ++j) {                        if (existed[j] == max)                            existed[j] = min;                    }                } else {                //只有一个点出现过                    if (existed[node2] == -1)                        existed[node2] = existed[node1];                    else                        existed[node1] = existed[node2];                    }                }            }        return true;    }};

对于一组数据，以上代码的执行过程如下表所示：

existed

0

1

2

3

4

edges

更新existed

-1

-1

-1

-1

-1

[0, 1]

existed[0] = 0

existed[1] = 0

0

0

-1

-1

-1

[1, 2]

existed[2]= 0

0

0

0

-1

-1

[3, 4]

existed[3]= 3

existed[4]= 3

0

0

0

3

3

[1, 3]

existed[3]= 0

existed[4]= 0

-1

0

0

0

0

[2, 4]

existed[2]==existed[4]

-1

0

0

0

0

存在问题：

      合并两个集合时，需要多次遍历existed数组，将点所对应位置的值替换，产生了冗余。如[3, 4]加入时，3,4对应位置都变为3，再加入[1,3]边时，需要遍历数组，找到对应值为3的位置，将3换成0。

改进办法：

     通过递归实现深度遍历，每次都在existed中寻找点的父节点，如果两个点具有相同的父节点，则图不为树。
AC代码(56ms):

class Solution {public:    /**     * @param n an integer     * @param edges a list of undirected edges     * @return true if it's a valid tree, or false     */    int find(vector<int> &existed, int e){        //点未在图中出现过,返回该点；否则，找到该点的父节点        if (existed[e] == -1)            return e;        else            return find(existed, existed[e]);    }    bool validTree(int n, vector<vector<int>>& edges) {        // Write your code here        //如果边的个数不等于点的个数减一，返回false        if (n - edges.size() != 1)            return false;        vector<int> existed(n, -1);        for (int i = 0; i < edges.size(); ++i) {            int root1 = find(existed, edges[i][0]);            int root2 = find(existed, edges[i][1]);            if (root1 == root2)                return false;            //将两个点关联            existed[root2] = root1;        }        return true;    }};

对于相同一组数据，执行过程如下表所示：

existed

0

1

2

3

4

edges

调用find

更新existed

-1

-1

-1

-1

-1

[0, 1]

find(0) = 0

existed[1] = 0

-1

0

-1

-1

-1

find(1) = 1

[1, 2]

find(1) = find(0) = 0

existed[2] = 0

-1

0

0

-1

-1

find(2) = 2

[3, 4]

find(3) = 3

existed[4] = 3

-1

0

0

-1

3

find(4) = 4

[1, 3]

find(1) = find(0) = 0

existed[3] = 0

-1

0

0

0

3

find(3) = 3

[2, 4]

find(2) = find(0) = 0

find(2) == find(4)

false

-1

0

0

0

3

find(4) = find(3) = find(0) = 0

【小结】

1. 使用一维数组表示图的有向边的指向，简单直观，节省空间，只需要开辟大小为n的数组，并且规定每个点对应位置的值为父节点即可。方便通过深度遍历的方法迅速找到当前点的父节点；

2. 第一种方法在使用数组时，将属于同一根节点的点表示为一个集合，具体表现为这些点对应位置的值都替换为集合中当前最小的结点，每次更新数组时需要先比较两个节点对应位置的大小，并且合并两个集合时都需要遍历数组；

3. 改进后的方法，避免了比较大小的操作和对数组的反复遍历，保证每次更新操作只改变一个结点对应位置的值，将该点对应位置处的值改为当前能找到的最高父节点，但find函数递归实现深度遍历，需要不断压栈，弹栈，产生额外地时间，空间消耗，可以将递归改为循环，避免栈的开销。改进后的代码也更简洁，易读。

int find(vector<int> &existed, int e){        //点未在图中出现过,返回该点；否则，找到该点的父节点        while (existed[e] != -1) {            e = existed[e];        }        return e;}