2021-01-16

【leetcode】 最小高度数

1.递归解法（时间复杂度高，容易超时）

class Solution {
private:
    int dfs(int node,int* visit,vector<vector<int>>&edges)
    {
        int height = 1;  //数高
        int now=0;
        int i;

        for (i=0;i<edges.size();++i)
            if (edges[i][0]==node && visit[edges[i][1]]==0)
            {    visit[edges[i][1]] = 1;
                 int d = dfs(edges[i][1],visit,edges);
                 now = max(d,now);
            }
            else if (edges[i][1]==node && visit[edges[i][0]]==0)
            {    visit[edges[i][0]] = 1;
                 int d = dfs(edges[i][0],visit,edges);
                 now = max(d,now);
            }
        height += now;
        return height;     
    }
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) 
    {
        vector <int> res;
        int *visit = new int[n];
        int min = n;
        
        for (int i=0;i<n;++i)
        {
            for (int k=0;k<n;++k)    //初始化
                visit[k] = 0;
            visit[i] = 1;
            int d = dfs(i,visit,edges);  //从i开始深度遍历
            if (d<min)
            {
                min = d;
                res.clear();
                res.push_back(i);
            }
            else if (d==min)
                res.push_back(i);
        }
        
        return res;
    }
};

2.非递归解法

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) 
    {

        vector <int> res,erase,cut;
        int left = n;
        int *degree = new int[n];
        for (int i=0;i<n;++i)         //初始化
            degree[i] = 0;
        for (int i=0;i<edges.size();++i)      //存每个节点的度
        {
            ++degree[edges[i][0]];
            ++degree[edges[i][1]];
        }
       
        while(left>2)
        {
            cut.clear();
            erase.clear();
            for(int i=0;i<n;++i)
                if (degree[i]==1)
                {
                    cut.push_back(i);
                    for (int j=0;j<edges.size();++j)
                    {                     
                        if (edges[j][0] == i)
                            erase.push_back(edges[j][1]);
                        if (edges[j][1] == i)
                            erase.push_back(edges[j][0]);
                    }
                }
            for (int i=0;i<cut.size();++i)
                degree[cut[i]] = -1;
            for (int i=0;i<erase.size();++i)
                --degree[erase[i]]; 
            left -= cut.size();
            
        }
        
        for(int i=0;i<n;++i)
            if (degree[i]==1||degree[i]==0)
                res.push_back(i);
        return res;
    }
};