hihoCoder #1490 : Tree Restoration 微软2017在线笔试题

题意

• 给你一棵树，已知其中全部节点的编号（1~n），节点所在层次，节点在该层从左到右是第几个节点，叶子节点编号以及叶子节点间的距离，但不知节点之间的边信息，要求重构这棵树，输出每个节点的父亲节点。

思路

• 我们考虑如果先不使用其他信息，只使用层次遍历的信息以及叶子节点编号的信息可以确定下来哪些节点的父亲节点
• 实际上我们可以找到最靠左的叶子节点，即该叶子节点满足如下性质，设节点编号为$u$，节点所在层为$level(u)$，第$i$层中最左节点编号为$left(i)$，总层数为$m$，
  $$\begin{eqnarray} u &= \mathop{\arg\min}_u level(u) \\ s.t. & u = left(level(u)) \end{eqnarray}$$

• 显然这样的叶子节点只有一个，沿着该叶子节点往上找每层最左的节点即是当前节点的父亲节点，如下图红色节点所示。
  

• 整个红色分支都可以标记，但为了后续处理方便，我们只处理左下的单链（即最左下的一棵子树，子树上的的节点都只有一个孩子），例如上图中我们只处理位于最左下方那个的红色节点，它上方的节点由于有两个分支，所以就先保留不处理。然后已经被标记的点从树中删除，重新找最左的叶子节点。处理后的结果如下图所示。
  

• 重复上述步骤，直至所有节点都被标记后即可。
• 那么之后的问题，就是如何在已知当前最左叶子节点的情况下，求下一次的最左叶子节点
• 我的方法是，先找出和当前最左叶子节点最近公共祖先层数最大的叶子节点集合（通过叶子节点之间的距离和叶子节点的层数可以直接算出），从中选出行排序最小的，若行排序一样，则选取最矮的节点
• 注意这个行排序会随树的变化动态变化，且和当前叶子节点的层数有关，因为下次会把当前叶子节点删去，所以比当前叶子节点矮的叶子节点的次序需要被减一

实现

#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
#define pb push_back
const int MAXN = 1e2+5;
int dist[MAXN][MAXN];
vector<int> g[MAXN];

int nums[MAXN];
int ans[MAXN];

//每行最左id 
int left1[MAXN];
//叶子id反向映射节点id 
int rleaf[MAXN];
//同层的右侧节点id 
int right1[MAXN];
//节点在自己层所排位置 
int cixu[MAXN];
//节点深度 
int dep[MAXN];
int vis[MAXN];
//动态更新的数组，表示当前状态下，一层已经有多少个偏左侧节点已找到父亲 
int jiancixu[MAXN];

int main(){
    ios::sync_with_stdio(false);
    int n,m,k;
    cin>>n>>m>>k;
    for (int i=0;i<m;i++){
        cin>>nums[i];
    }
    for (int i=0;i<m;i++){
        for (int j=0;j<nums[i];j++){
            int tmp;
            cin>>tmp;
            g[i].pb(tmp);
            cixu[tmp] = j;
            dep[tmp] = i;
        }
        left1[i] = g[i][0];
    }
    for (int i=0;i<m;i++){
        for (int j=0;j<nums[i]-1;j++){
            right1[g[i][j]] = g[i][j+1];
        }
        right1[g[i][nums[i]-1]] = -1;
    }
    int now = -1;
    int nowTmp = inf;
    for (int i=0;i<k;i++){
        int tmp;
        cin>>tmp;
        rleaf[i] = tmp;
        for (int j=0;j<m;j++){
            if (tmp == left1[j]){
                if(nowTmp > j){
                    now = i;
                    nowTmp = j;
                }
                break;
            }
        }
    }
    for (int i=0;i<k;i++){
        for (int j=0;j<k;j++){
            cin>>dist[i][j];
        }
    }
    vis[now] = 1;
    for (int i=0;i<k-1;i++){
        int maxn = -1, minx = inf, mind = inf;
        int next = -1;
        for (int j=0;j<k;j++){
            if (vis[j])
                continue;
            int nn = (dep[rleaf[now]] + dep[rleaf[j]] - dist[now][j]) >> 1;
            if (dep[rleaf[j]] > dep[rleaf[now]]){
                if (nn > maxn || nn == maxn && cixu[rleaf[j]] - jiancixu[dep[rleaf[j]]]< minx 
                    || nn == maxn && cixu[rleaf[j]] - jiancixu[dep[rleaf[j]]] == minx && dep[rleaf[j]] < mind){
                    maxn = nn;
                    minx = cixu[rleaf[j]] - jiancixu[dep[rleaf[j]]];
                    mind = dep[rleaf[j]];
                    next = j;
                }
            }
            else{
                if (nn > maxn || nn == maxn && cixu[rleaf[j]] - jiancixu[dep[rleaf[j]]] - 1 < minx 
                    || nn == maxn && cixu[rleaf[j]] - jiancixu[dep[rleaf[j]]] - 1 == minx && dep[rleaf[j]] < mind){
                    maxn = nn;
                    minx = cixu[rleaf[j]] - jiancixu[dep[rleaf[j]]] - 1;
                    mind = dep[rleaf[j]];
                    next = j;
                }
            }
        }
        vis[next] =  1;
        int zulev = (dep[rleaf[now]] + dep[rleaf[next]] - dist[now][next]) >> 1;
        int lowlev = dep[rleaf[now]];
        for (int j=lowlev;j>zulev;j--){
            ans[left1[j]] = left1[j-1];
            left1[j] = right1[left1[j]];
            jiancixu[j]++;
        }
        now = next;
    }
    int lowlev = dep[rleaf[now]];
    for (int j=lowlev;j>0;j--){
            ans[left1[j]] = left1[j-1];
    }
    for (int i=1;i<=n;i++){
        if (i != n)
            cout << ans[i] << " ";
        else
            cout << ans[i] << "\n";
    }
    return 0;
}