Sicily 1140 国王的遗产

N个黄金N-1条链，是树结构。

盲搜，搜索状态空间：每次切掉一条边后出现的两个子图。问题转化为怎么样表示和比较这些子图。

显而易见，其中一个子图是原树的一个子树，另一个子图就是该子树的补图。子树可以用它的根来表示。再考虑如何比较它们的优劣，如果大小不同，结果易得，如果大小一样，则需要进一步处理各自“编号组”，麻烦，分析如下。

考虑最简单的情况：子树与另一个子树。将它们各自的编号组表示为序列A[1...X]. 找到第一个不匹配的ID，较小那个为优。最先考虑它们各自的minID。拥有相同的minID的子树的根是minID的祖先结点，而以minID的各个祖先作为根的子树的大小不可能一样，所以大小一样的子树minID不可能一样，因此实际上这里只需要考虑它们的minID，较小者为优。

然后考虑两种补图相互比较。这时可借助其对应的子树。两个补图与其对应的子树相加，和序列一样，则对应的子树的子序列越优，它自身的子序列就越差。

再考虑补图与子树的比较（两者不一定对应）。补图或者与子树不相交，这时仍可用minID，或者包含子树，就比较麻烦。能不能从补图与子图的差入手？根必然是差的子集，由于整棵树不是有向的，谁作为根都无所谓，不影响搜索结果，如果搜索时一直都把最小的ID作为根，就保证了所有补图的minID都比所有子树的小。

#include <iostream>
#include <list>
#include <vector>
#include <algorithm>

using namespace std;

struct Node {
	list<int> adjacentVertexes;
	int minID;	// 以该结点为子根的子树的最小ID
	int subtreeNodesCount;	// 以该结点为子根的子树的结点总数
};

struct SubGraph {
	enum GraphType {WITH_ROOT, WITHOUT_ROOT};
	// WITHOUT_ROOT表示切除边后的子树, WITH_ROOT表示该子树的补图
	int inVertex, outVertex, subGraphNodesCount, minID;
	// inVertex, outVertex 描述切除的边
	// minID是切除后子树的minID
	GraphType type;
	SubGraph() {}
	SubGraph(int i, int o, int s, int m, GraphType t):
		inVertex(i), outVertex(o), subGraphNodesCount(s),
			minID(m), type(t) {}
};

void setNodes(vector<Node> &tree, int subRoot, int father) {
	tree[subRoot].subtreeNodesCount=1;
	tree[subRoot].minID=subRoot;
	for (list<int>::iterator iter=tree[subRoot].adjacentVertexes.begin(); 
		iter!=tree[subRoot].adjacentVertexes.end(); iter++)
		if (*iter!=father)
			setNodes(tree, *iter, subRoot);
	for (list<int>::iterator iter=tree[subRoot].adjacentVertexes.begin();
		iter!=tree[subRoot].adjacentVertexes.end(); iter++)
			if (*iter!=father) {
				tree[subRoot].subtreeNodesCount+=tree[*iter].subtreeNodesCount;
				tree[subRoot].minID=min(tree[subRoot].minID, tree[*iter].minID);
			}
}

bool better(SubGraph g, SubGraph h) {
	if (g.subGraphNodesCount!=h.subGraphNodesCount)
		return g.subGraphNodesCount>h.subGraphNodesCount;
	if (g.type==SubGraph::WITHOUT_ROOT) {
		if (h.type==SubGraph::WITHOUT_ROOT)
			return g.minID<h.minID;
		else
			return false;
	}
	else {
		if (h.type==SubGraph::WITHOUT_ROOT)
			return true;
		else
			return g.minID>h.minID;
	}
}

void searchAnswer(const vector<Node> &tree, int root, int subRoot, int father, SubGraph &g) {
	for(list<int>::const_iterator iter=tree[subRoot].adjacentVertexes.begin();
		iter!=tree[subRoot].adjacentVertexes.end(); iter++)
		if (*iter!=father) {
			if (tree[*iter].subtreeNodesCount*2<=tree[root].subtreeNodesCount) {
				SubGraph h1(subRoot, *iter, tree[*iter].subtreeNodesCount, 
					tree[*iter].minID, SubGraph::WITHOUT_ROOT);
				if (better(h1, g))
					g=h1;
			}
			int tmp=tree[root].subtreeNodesCount-tree[*iter].subtreeNodesCount;
			if (tmp*2<=tree[root].subtreeNodesCount) {
				SubGraph h2(subRoot, *iter, tmp, tree[*iter].minID, SubGraph::WITH_ROOT);
				if (better(h2, g))
					g=h2;
			}
		}
	for(list<int>::const_iterator iter=tree[subRoot].adjacentVertexes.begin();
		iter!=tree[subRoot].adjacentVertexes.end(); iter++)
		if (*iter!=father)
			searchAnswer(tree, root, *iter, subRoot, g);
}

int main() {
	int n, k;
	cin>>n>>k;

	// 构造树
	vector<Node> tree(n+1);
	for (int i=1; i<=n-1; i++) {
		int a, b;
		cin>>a>>b;
		tree[a].adjacentVertexes.push_back(b);
		tree[b].adjacentVertexes.push_back(a);
	}
	int root=1;

	// 求解
	vector<int> answers;
	SubGraph g;
	// 前k-1个
	for (int i=1; i<=k-1; i++) {
		setNodes(tree, root, 0);
		g.subGraphNodesCount=0;
		searchAnswer(tree, root, root, 0, g);
		answers.push_back(g.subGraphNodesCount);
		if (g.type==SubGraph::WITH_ROOT) {
			tree[g.outVertex].adjacentVertexes.erase(
				find(tree[g.outVertex].adjacentVertexes.begin(),
					tree[g.outVertex].adjacentVertexes.end(), g.inVertex));
			// 去掉子树的补图
			root=tree[g.outVertex].minID;
			// 新的根
		}
		else {
			tree[g.inVertex].adjacentVertexes.erase(
				find(tree[g.inVertex].adjacentVertexes.begin(),
					tree[g.inVertex].adjacentVertexes.end(), g.outVertex));
			// 去掉子树
		}
	}
	for (vector<int>::iterator iter=answers.begin(); iter!=answers.end(); iter++)
		cout<<(*iter)<<" ";

	// 第k个
	if (g.type==SubGraph::WITH_ROOT)
		cout<<tree[g.outVertex].subtreeNodesCount<<"\n";
	else
		cout<<tree[root].subtreeNodesCount-g.subGraphNodesCount<<"\n";

	return 0;
}

// by wbchou
// Feb 18th, 2013