D. Numbers on Tree

http://codeforces.com/contest/1287/problem/D

思路：

1. 每个子树维护一个数组，包含所有节点的编号和值，且按值排序。

2. 每个子子树的数组需要合并到父节点表示的父子树中，合并需要维护按照值的递增顺序。

3. 所有子子树合并到当前节点表示的父子树中后需要确定当前节点的值，因为数组是有顺序的，所以直接插入到对应的位置就可以，然后值需要比前一个点的值+1，有序数组后续的点如果由小于当前点的值，则需要集体+1，这样就满足了所有子子树中有多少个点小于自己. 这种方式之所以正确是因为保证了每个子子树中任意两点之间的关系没有实质性的改变。

代码：

#include <iostream>
#include <string>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <vector>
#include <stack>
 
using namespace std;
 
typedef long long LL;
 
const int N = 20001;
int ans[N];
int f[N];
int sub[N];
int num[N];

struct node
{
    int g, index;

    node(int g, int index)
        :g(g), index(index)
    {}
};
vector<node> vt[N];

void merge(vector<node>& f, vector<node>& s)
{
    vector<node> tmp;
    for (int i = 0, j = 0; i < f.size() || j < s.size(); )
    {
        if (i >= f.size())
        {
            tmp.push_back(s[j]);
            j++;
            continue;
        }
        if (j >= s.size())
        {
            tmp.push_back(f[i]);
            i++;
            continue;
        }
        if (f[i].g < s[j].g)
        {
            tmp.push_back(f[i]);
            i++;
        }
        else
        {
            tmp.push_back(s[j]);
            j++;
        }
    }
    f = move(tmp);
}
 
int main()
{
    int n;
    while (cin>>n)
    {
        memset(f, 0, sizeof(f));
        memset(num, 0, sizeof(num));
        memset(sub, 0, sizeof(sub));
        memset(ans, 0, sizeof(ans));
        for (int i = 0; i < N; ++i)
        {
            vt[i].clear();
        }
        for (int i = 1; i <= n; ++i)
        {
            int p, k;
            cin>>p>>k;
            num[i] = k;
            f[i] = p;
            sub[p]++;
        }
        stack<int> st;
        for (int i = 1; i <= n; ++i)
        {
            if (sub[i] == 0)
            {
                st.push(i);
            }
        }
        bool has_ans = true;
        while (!st.empty())
        {
            int index  = st.top();
            st.pop();

            int k = num[index];

            if (vt[index].size() < k)
            {
                has_ans = false;
                break;
            }

            vt[index].insert(vt[index].begin() + k, node(0, index));
            for (int i = k; i < vt[index].size(); ++i)
            {
                if (i == k)
                {
                    if (i - 1 >= 0)
                    {
                        vt[index][i].g = vt[index][i-1].g + 1;
                    }
                    else
                    {
                        vt[index][i].g = 1;
                    }
                    continue;
                }
                if (i == k+1)
                {
                   if (vt[index][i].g >= vt[index][k].g)
                   {
                       break;
                   }
                }
                vt[index][i].g ++;
            }

            int p = f[index];
            if (0 == p)
            {
                for (int i = 0; i < vt[index].size(); ++i)
                {
                    ans[vt[index][i].index] = vt[index][i].g;
                }
                break;
            }

            merge(vt[p], vt[index]);            
            
            sub[p]--;
            if (0 == sub[p])
            {
                st.push(p);
            }
        }
        if (!has_ans)
        {
            cout << "NO" << endl;
        }
        else
        {
            cout << "YES" << endl;
            for (int i = 1; i <= n; ++i)
            {
                cout << ans[i];
                if (i != n)
                {
                    cout << " ";
                }
            }
            cout << endl;
        }
    }
    return 0;
}