*[codility]Country network

https://codility.com/programmers/challenges/fluorum2014

http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1273

http://blog.csdn.net/caopengcs/article/details/36872627

http://www.quora.com/How-do-I-determine-the-order-of-visiting-all-leaves-of-a-rooted-tree-so-that-in-each-step-I-visit-a-leaf-whose-path-from-root-contains-the-most-unvisited-nodes#

思路如曹博所说，先dfs记录离根的距离，来的方向的前驱。然后按距离排序，之后按此排序求有意义的增加距离。

直观感受是，如果两个叶子在一个分叉上，显然深的节点更先被访问，如果不在一个分叉上，那么先算深的也没什么损失。最后，按照这个权值再对叶子排序一次，就是所要的结果。

#include <iostream>

using namespace std;

void dfs(vector<vector<int>> &tree, vector<int> &parent, vector<int> &depth, vector<bool> &visited, int root, int dep) {

    visited[root] = true;

    depth[root] = dep;

    for (int i = 0; i < tree[root].size(); i++) {

        if (visited[tree[root][i]])

            continue;

        parent[tree[root][i]] = root;

        dfs(tree, parent, depth, visited, tree[root][i], dep + 1);

    }

}



vector<int> solution(int K, vector<int> &T) {

    int n = T.size();

    vector<vector<int>> tree(n);

    for (int i = 0; i < n; i++) {

        if (T[i] != i) {

            tree[i].push_back(T[i]);

            tree[T[i]].push_back(i);

        }

    }

    vector<int> parent(n);

    vector<int> depth(n);

    vector<bool> visited(n);

    dfs(tree, parent, depth, visited, K, 0);

    vector<vector<int>> cnt(n);

    for (int i = 0; i < n; i++) {

        cnt[depth[i]].push_back(i);    

    }

    vector<int> ordered;

    for (int i = n - 1; i >= 0; i--) {

        for (int j = 0; j < cnt[i].size(); j++) {

            ordered.push_back(cnt[i][j]);    

        }

    }

    vector<int> res;

    vector<int> length(n);

    visited.clear();

    visited.resize(n);

    visited[K] = true;

    for (int i = 0; i < ordered.size(); i++) {

        int len = 0;

        int x = ordered[i];

        while (!visited[x]) {

            visited[x] = true;

            x = parent[x];

            len++;

        }

        length[ordered[i]] = len;

        //cout << "length[" << ordered[i] << "]:" << len << endl;

    }

    

    cnt.clear();

    cnt.resize(n);

    for (int i = 0; i < length.size(); i++) {

        cnt[length[i]].push_back(i);    

    }

    res.push_back(K);

    for (int i = cnt.size() - 1; i > 0; i--) {

        for (int j = 0; j < cnt[i].size(); j++) {

            res.push_back(cnt[i][j]);

        }

    }

    return res;

}