310. Minimum Height Trees Add to List

LeetCode

• 题目地址：https://leetcode.com/problems/minimum-height-trees/#/description

• 思考过程：

  • 题目要求是给一个具有树的属性的无向图，即每个点仅被另一条边连在一起，也就是说对于n个节点的图，只有n-1条边。题目目的是要找到其中一个节点作为根节点，能使得整个树的高度最小，这样的树叫做Minimum Height Tree(MHT)。
  • 于是我一开始的想法很简单，（1）先根据输入构造边的一个map，（2）然后对从第0～n-1节点，计算一次深度，（3）最后根据深度的大小来返回MHT的根节点。但是这么做会在n=1000左右的时候超时，时间复杂度应该是O($n^2$)，因为一共有n个点，每个点计算以它为根的深度，通过BFS来计算，复杂度是O(V+2E)，因为是无向图每条边最多需要判断两次，每个点遍历一次，而V=n，E=n-1，复杂度即O( n <script type="math/tex" id="MathJax-Element-242">n</script>)，这样的过程有n次
  • 然后参考了一下solution，只看了一下人家的思路，然后自己理解后写，思路大概是这样的，每次找到只有一条边连着的节点，剔除它，并剔除所有和他相连的边，最后剩下一个点或者两个点(一起连着，都是MHT的根节点)，对于这个的时间复杂度就是O(V+E)，因为对于每个点只访问一次，并且删除，同时对于每个边删除一次，由于V=n，E=n-1，所以O(n)
  • 最后我的代码和答案的代码的对比，最主要的区别就是存储的时候，我用的是map，而答案用的是vector。这里我用map的原因是，每次检查到与该节点连接的边个数只有1的时候，需要把该节点删除，而map删除比vector快。但是答案的思路应该是每个节点只有一次机会，边数会变成1(变成是一个过程，从2然后erase一条边之后变成1)，而之前边数是1的点不需要删除，因为下次再到它的时候(一定会再到它，因为无向图边是双向的)，它的边数从1变成0，不会被考虑进去，也即相当于删除了，而在这里他节省了一些时间，所以我的算法和它的应该在常数项中会有点区别，毕竟对于unordered_map这种哈希map的删除时间应该是O(1)的，那么每次计算，我的复杂度会多O(n)，但是总共的复杂度仍然是O(n)

• 代码
  这是最开始自己的思路，超时

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
        vector<int> v; 
        int min = INT_MAX;
        //construct m
        for (vector<pair<int,int>>::iterator it = edges.begin(), end = edges.end(); it != end; it++) {
            int one = it->first, two = it->second;
            m[one].push_back(two);
            m[two].push_back(one);
        }
        bool visit[n];
        for (int i = 0; i < n; i++) {
            memset(visit,0,sizeof(visit));
            int dep = depthWithNode(i,visit);
            //cout << "i: " << i << " dep: " << dep << endl;
            if (dep < min) {
                v.clear();
                v.push_back(i);
                min = dep;
            } else if (dep == min)
                v.push_back(i);
        }
        return v;
    }
    //calculate depth with root node k
    int depthWithNode(int k, bool* visit) {
        //initial
        clearCur();
        clearNext();
        cur.push(k);
        visit[k] = true;
        int height = 0;

        while (!cur.empty()) {
            height++;
            while (!cur.empty()) {
                int tmp = cur.front();
                cur.pop();
                for (int i = 0; i < m[tmp].size(); i++) {
                    if (!visit[m[tmp][i]]) {
                        next.push(m[tmp][i]);
                        visit[m[tmp][i]] = true;
                    }
                }
            }
            cur = next;
            clearNext();
        }
        return height;
    }
    void clearCur() {
        while (!cur.empty())
            cur.pop();
    }
    void clearNext() {
        while (!next.empty())
            next.pop();
    }
private:
    map<int,vector<int>> m;
    queue<int> cur;
    queue<int> next;
};

这是后来参考的思路，自己实现的，大概用时116ms

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
        vector<int> v(1,0); 
        //construct m
        for (vector<pair<int,int>>::iterator it = edges.begin(), end = edges.end(); it != end; it++) {
            int one = it->first, two = it->second;
            m[one].insert(two);
            m[two].insert(one);
        }
        while(m.size()) {
            v.clear();
            if (m.size() == 1) {
                v.push_back(m.begin()->first);
                break;
            }
            for (unordered_map<int,set<int>>::iterator it = m.begin(), end = m.end(); it != end; it++) {
                if (it->second.size() == 1)
                    v.push_back(it->first);
            }
            int leafSize = v.size();
            for (int i = 0; i < leafSize; i++) {
                for (set<int>::iterator it = m[v[i]].begin(), end = m[v[i]].end(); it != end; it++) {
                    m[*it].erase(v[i]);
                }
                m.erase(v[i]);
            }
        }
        sort(v.begin(),v.end());
        return v;
    }
private:
    unordered_map<int,set<int>> m;
};

这是答案的代码，和我写的有一点点不同，不同在思路中写到了这里不重复，大概耗时43ms

class Solution {
 public:
  vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
    // Initialize the undirected graph
    vector<set<int>> adj(n);
    for (vector<pair<int,int>>::iterator it = edges.begin(), end = edges.end(); it != end; it++) {
      adj[it->first].insert(it->second);
      adj[it->second].insert(it->first);
    }
    // Corner case
    vector<int> current;
    if (n == 1) {
      current.push_back(0);
      return current;
    }
    // Create first leaf layer
    for (int i = 0; i < adj.size(); ++i) {
      if (adj[i].size() == 1) {
        current.push_back(i);
      }
    }
    // BFS the graph
    while (true) {
      vector<int> next;
      for (int node : current) {
        for (int neighbor : adj[node]) {
          adj[neighbor].erase(node);
          if (adj[neighbor].size() == 1) next.push_back(neighbor);
        }
      }
      if (next.empty()) return current;
      current = next;
    }
  }
};