SOJ 1140. 国王的遗产

题目大意：给定一棵n个顶点，n-1条边的树。有k个孩子，前k-1个孩子切走树中顶点数不大于n/2的最大连通块，剩余的结点组成新的树。最后一个孩子得到剩余的树中的所有结点。

按顺序输出每个孩子能获得的顶点数。

解题思路：任选一结点作为根节点，使用深度优先搜索，获得相对于父节点一端，子节点一端的节点总数和节点最小值。再次使用深度优先搜索，反向求得相对于子节点一端，父节点一端的节点总数和节点最小值。如此能快速获取任意边两端的节点总数和节点最小值。只需要遍历边即可， 可以优化。

注意：需要证明，任意两种切法中，任意顶点不可能存在于两个合法长度相等的序列中。

代码如下：

#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <climits>
#include <vector>
#include <map>
using namespace std;

typedef pair<int, int> P;

struct Info {
    int nodeMinimal;
    int nodeCount;
};

const int maxn = 30001;

map<int, Info> G[maxn];

P search(int cur, int upper) {
    map<int, Info> &near = G[cur];

    int minimal = INT_MAX;
    int count = 0;
    map<int, Info>::iterator iter = near.begin();
    while (iter != near.end()) {
        if (iter->first != upper) {    // 如果不是上一层的结点，就往下搜索
            pair<int, int> p = search(iter->first, cur);    // p.first表示下一层的总结点数，p.second表示下一层的最小值
            iter->second.nodeCount = p.first;
            iter->second.nodeMinimal = p.second;
            count += p.first;
            minimal = minimal < p.second ? minimal : p.second;
        }
        ++iter;
    }

    return P(count + 1, minimal < cur ? minimal : cur);

}

void reverse_search(int cur, int upper, int upper_count, int upper_minimal, int tot) {
    // 考虑第一个起点和最底层点
    if (upper != -1) {
        Info & info = G[cur][upper];    // 反向标记
        info.nodeCount = upper_count;
        info.nodeMinimal = upper_minimal;
    }
    // 邻结点只有一个或者多个
    map<int, Info> &near = G[cur];
    if (near.size() == 1 && upper != -1) return;    // 如果邻结点只有upper，则不需要往下递归
    // 如果邻结点有两个或两个以上
    // 找最小值和次小值
    int most_minimal = INT_MAX, minimal = INT_MAX;
    map<int, Info>::iterator iter = near.begin();
    while (iter != near.end()) {
        int nodeMinimal = iter->second.nodeMinimal;
        if (nodeMinimal < most_minimal) {
            minimal = most_minimal;
            most_minimal = nodeMinimal;
        } else if (nodeMinimal < minimal) {
            minimal = nodeMinimal;
        }
        ++iter;
    }
    if (cur < most_minimal) {
        minimal = most_minimal;
        most_minimal = cur;
    } else if (cur < minimal) {
        minimal = cur;
    }


    // 遍历邻结点（ != upper），如果
    iter = near.begin();
    while (iter != near.end()) {
        if (iter->first != upper) {    // 如果邻结点不是Upper结点，则可以继续递归搜索
            int cur_count = tot - iter->second.nodeCount;
            int cur_minimal = iter->second.nodeMinimal == most_minimal ? minimal : most_minimal;
            reverse_search(iter->first, cur, cur_count, cur_minimal, tot);
        }
        ++iter;
    }

}

void findCutWay(const int & cur, const int & upper, int & from, int & to, int &nodeCount, int &nodeMinimal, const int & tot) {
    int half_tot = tot / 2;    // 总数的一半
    map<int, Info> & near = G[cur];
    map<int, Info>::iterator iter = near.begin();
    while (iter != near.end()) {
        if (iter->second.nodeCount <= half_tot) {    // 如果相邻块数量符合要求，则操作
            if (iter->second.nodeCount > nodeCount) {
                from = cur, to = iter->first;
                nodeCount = iter->second.nodeCount;
                nodeMinimal = iter->second.nodeMinimal;
            } else if (iter->second.nodeCount == nodeCount){
                // 假设不出现nodeMinimal == iter->second.nodeMinimal的情况
                nodeMinimal = nodeMinimal < iter->second.nodeMinimal ? nodeMinimal : (from = cur, to = iter->first,iter->second.nodeMinimal);
            }
            if (iter->second.nodeCount == half_tot && iter->first != upper) // 如果刚好一半，要测试另一侧，可简化；如果少于一半，则不继续递归
                findCutWay(iter->first, cur, from, to, nodeCount, nodeMinimal, tot);
        } else if (iter->first != upper) {
            findCutWay(iter->first, cur, from, to, nodeCount, nodeMinimal, tot);
        }
        ++iter;
    }
}

void cut(int & root, int &num, int tot) {
    // 从root开始处理整棵树并做标记 G[from][to].nodeCount , G[from][to].nodeMinimal
    search(root, -1);

    // 把剩余的标记 : 反向标记
    reverse_search(root, -1, 0, INT_MAX, tot);

    // 遍历整棵树，找到可以切的位置
    int from, to, nodeCount = 0, nodeMinimal = INT_MAX;
    findCutWay(root, -1, from, to, nodeCount, nodeMinimal, tot);

    // 真正切
    G[from].erase(to);
    G[to].erase(from);
    root = from;
    num = nodeCount;
}

int main() {
    int n, k;
    scanf("%d%d", &n, &k);
    int a, b;
    for (int i = 1; i < n; ++i) {
        scanf("%d%d", &a, &b);
        G[a][b];
        G[b][a];
    }
    // srand(rand());
    int root = rand() % n + 1;    // 随机生成根节点

    int num;
    int sum = 0;
    vector<int> ans;
    while (--k, k) {    // 对金块链 切k-1次
        cut(root, num, n - sum);
        sum += num;
        ans.push_back(num);
        // 如果剩余的少于2，则给下一位，并且退出
        if (n - sum < 2) {
            break;
        }
    }

    // ans.push_back() 剩下的连通图  n - 前面的总和
    ans.push_back(n - sum);
    for (int i = 1; i < k; ++i) ans.push_back(0);

    // 输出结果
    for (int i = 0; i < ans.size(); ++i) {
        printf("%d%c", ans[i], i == ans.size() - 1 ? '
' : ' ');
    }

    return 0;
}