codility上的问题(34) Fluorum 2014

好久没写codility的题了。一来没时间，二来有的题目不太好分析。这个题比較有意思，我还没有给出很严格的证明。

aaarticlea/png;base64,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" alt="" />

给定一棵树（无向无环图）。从一个节点出发，每次选择一个节点，从起点到目的节点的路径上没经过的节点尽可能多，直到遍历全然部的节点。假设起点到两个目的节点的路径中没经过的节点相同多，则选择标号较小的节点作为目的节点。如此继续，直到遍历全部的节点，求按顺序选择了哪些目的节点？

比如从2 開始。第一次选择0。然后1，0变为经历过的节点。

然后从0開始，第二次选择6。 然后4，6变为经历过的节点。

然后从6開始，第三次选择3。然后3变为经历过的节点。

然后从3開始，最后一次选择5。然后5变为经历过的节点。

输出[2,0,6,3,5]

函数头部是 vector<int> solution(int K, vector<int> &T);

当中K是起点编号。(i，T[i])表示树的一条边。

变量范围节点数N， [1..90,000]，T元素范围[0..N-1]

要求时间复杂度O(N),空间复杂度O(N)。

分析： 我认为这个题我没能完美的解决，由于没给出严格的证明。首先目标节点肯定是叶子，直观上深度更深的叶子更有效。

所以我按叶子深度由大到小对叶子排序，假设深度相同。我把编号小的叶子放前面。依照这个既定顺序给叶子定义权值，这个权值就是最后訪问路径上经历的新节点数（这个须要严格证明）。权值的定义例如以下。沿着叶子不断向父亲走。直到第一个标记过的节点停止。这条路径上的节点数作为叶子的权值。而且这条路径上的节点都设置未标记过。关键问题是，要依照之前排好的顺序给每一个叶子算权值（由于顺序会影响叶子的权值）。

直观感受是，假设两个叶子在一个分叉上。显然深的节点更先被訪问，假设不在一个分叉上。那么先算深的也没什么损失。最后。依照这个权值再对叶子排序一次，就是所要的结果。为了满足时间复杂度。我採用的是基数排序，写了一个help函数完毕排序。

所以大概思路就是：

（1） 先dfs一次，得到每一个叶子的深度和每一个节点的父亲

（2） 对全部叶子按深度进行基数排序

（3） 依照排好的顺序计算每一个叶子的权值（复杂度相当于遍历树，由于是沿着叶子向上遍历的）

（4） 依照计算的权值，再对叶子做一次基数排序 得到终于结果。

终于代码：

// you can also use includes, for example:
// #include <algorithm>

void help(int n, vector<pair<int,int> > &v) {  // (id, weight)
    vector<vector<int> > have;
    have.resize(n);
    for (int i = 0; i < v.size(); ++i) {
        have[v[i].first].push_back(v[i].second);
    }
    v.clear();
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < have[i].size(); ++j) {
            v.push_back(make_pair(i, have[i][j]));
        }
    }
    have.clear();
    have.resize(n);
    for (int i = 0; i < v.size(); ++i) {
        have[v[i].second].push_back(v[i].first);
    }
    v.clear();
    for (int i = n - 1; i >= 0; --i) {
        for (int j = 0; j < have[i].size(); ++j) {
            v.push_back(make_pair(have[i][j] , i));
        }

    }
}
void dfs(int x,int p,int d,vector<int> &depth, vector<int> &parent,vector<vector<int> > & con) {
    parent[x] = p;
    depth[x] = d;
    for (int i = 0; i < con[x].size(); ++i) {
        if (con[x][i] != p) {
            dfs(con[x][i], x, d + 1, depth, parent, con);
        }

    }

}
vector<int> solution(int K, vector<int> &T) {
    // write your code in C++98
    vector<vector<int> > con;
    int n = T.size();
    con.resize(n);
    for (int i = 0; i < n; ++i) {
        if (T[i] != i) {
            con[i].push_back(T[i]);
            con[T[i]].push_back(i);
        }
    }
    vector<int> parent, depth;
    depth.resize(n);
    parent.resize(n);
    dfs(K, -1, 0, depth, parent, con);
    vector<pair<int,int> > v;
    for (int i = 0; i < n; ++i) {
        if ((i != K)  && (con[i].size() == 1)) {  //leaf
            v.push_back(make_pair(i, depth[i]));
        }
    }
    help(n,v);
    vector<bool> mark;
    mark.resize(n, false);
    for (int i = 0; i < v.size(); ++i) {
        int x = -1;
        for (int j = v[i].first; (j >= 0) && (!mark[j]); ++x, j = parent[j]) {
            mark[j] = true;
        }
        v[i].second = x;
    }
    help(n,v);
    vector<int> result;
    result.push_back(K);
    for (int i = 0; i < v.size(); ++i) {
        result.push_back(v[i].first);
    }
    return result;
}