*[hackerrank]Tree Covering

https://www.hackerrank.com/contests/illuminati/challenges/tree-covering

这道题先是在上次交流讨论了一下，然后两位百度的朋友先写完代码share出来了,觉得是道很好的题，就做了一下。https://gist.github.com/coder32167/6964331 https://gist.github.com/snakeDling/6965299
基本思想是贪心。根据题意，所选的点必然是叶子节点，那么首先找出树的直径，直径上的这两个点都要。找第三个点的时候，遍历所有的点，找出到直径（上任意一点）距离最小的叶子节点，接着以此类推找第四个点。
贪心可行的依据可直观的这么看，假设AB是树的直径，那么从树中任意一其他叶子X出发寻找最长路，要么是AX，要么是BX。这个是广为证明的一个结论，已经用于寻找直径了。
接下来就是实现，怎么求第三个点，第四个点呢。答案是递归BFS,递归到叶子节点时cover是1，然后往上回溯。对任意父节点，取子节点中cover数最大的加一，剩下的都放入vector中，最后排序。（或者放入堆中也可，就不用最后排序了。）
最后依次把这些branch加回去。过程如下示意图展示：就是先取直径上任意一点，然后根据BFS得到的排序的branch长度，一个一个按顺序将剩余段加入回去。

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

int get_root(vector<vector<int>> &tree, int root) {
    int n = tree.size();
    vector<bool> visit(n, false);
    vector<int> len(n);
    queue<int> que;

    int max_len = 1;
    que.push(root);
    len[root] = 1;
    while (!que.empty()) {
        int node = que.front();
        que.pop();
        if (visit[node]) 
            continue;
        visit[node] = true;
        int m = tree[node].size();
        if (len[node] > max_len) {
            root = node;
            max_len = len[node];
        }
        for (int i = 0; i < m; i++) {
            que.push(tree[node][i]);
            len[tree[node][i]] = len[node] + 1;
        }
    }
    return root;
}

int collect_branch(vector<vector<int>> &tree, int root, vector<int> &branch, vector<bool> &visit) {   
    visit[root] = true;
    int m = tree[root].size();
    vector<int> result;
    for (int i = 0; i < m; i++) {
        if (visit[tree[root][i]])
            continue;
        int len = collect_branch(tree, tree[root][i], branch, visit);
        result.push_back(len);
    }
    if (result.size() == 0)
        return 1;
    sort(result.begin(), result.end());
    int ret = result.back();
    result.pop_back();
    for (int i = 0; i < result.size(); i++) {
        branch.push_back(result[i]);
    }
    return ret + 1;
}

int main()
{
    int n;
    scanf("%d", &n);
    vector<vector<int>> tree(n+1);
    for (int i = 1; i < n; i++) {
        int a, b;
        scanf("%d", &a);
        scanf("%d", &b);
        tree[a].push_back(b);
        tree[b].push_back(a);
    }

    int root = get_root(tree, 1);
    vector<int> branch;
    vector<bool> visit(n+1, false);
    int main_branch = collect_branch(tree, root, branch, visit);
    branch.push_back(main_branch);
    sort(branch.begin(), branch.end());

    printf("%d\n", 1);
    int total = 0;
    for (int i = 1; i < n; i++) {
        if (branch.size() != 0) {
            total += branch.back();
            branch.pop_back();
        }
        printf("%d\n", total);
    }

    return 0;
}