std::vector<chess_node> build_tree(const chess_node & root, const int side,const std::vector<chess_node> & history)
{
	std::vector<chess_node> tree;
	std::unordered_set <std::string> dict;
	//...
	size_t curr_i = 0;
	size_t max_nodes = 1024*1024*4;
	while (tree.size()<=max_nodes && curr_i<tree.size())
	{
		const size_t ts = tree.size();
		const int cores = omp_get_num_procs();
		std::vector<std::vector<chess_node> > vec_appends;
		for (int i=0;i<cores;++i)
			vec_appends.push_back(std::vector<chess_node>());
		std::atomic<int> new_appends (0);
#pragma omp parallel for
		for (int i=curr_i;i<ts;++i)
		{
			if (new_appends + ts >=max_nodes)
				continue;
			const unsigned char clock = tree[i].depth;
			const int tid = omp_get_thread_num();
			if ((tree[i].alive & 0x00010001)==0x00010001)
			{
				const int curr_side = (side + clock) % 2;
				std::vector<chess_node> next_status =
						expand_node(tree[i],curr_side);

				const size_t sz = next_status.size();
				for (size_t j=0;j<sz;++j)
				{
					std::string ha = node2hash(next_status[j].coords,next_status[j].alive);
					bool needI = false;
#pragma omp critical
					{
						if (dict.find(ha)==dict.end())
						{
							needI = true;
							dict.insert(ha);
						}
					}
					if (needI)
					{
						//...
						vec_appends[tid].push_back(next_status[j]);
						//...
					}
				}
			}
		}
		for (int i=0;i<cores;++i)
		{
			if (vec_appends[i].size())
				std::move(vec_appends[i].begin(),vec_appends[i].end(),std::back_inserter(tree));
		}
		curr_i += (ts - curr_i);
	}
	//...
	return tree;
}

3.3 跳转概率与代价传递

对某个节点来说，其具备红黑属性。谁都会选择对自己最有利的局面走。因此，当前节点的跳转概率就是对手的代价/我的代价。

当遍历时，从最底层节点开始，往根部遍历。各个节点的本级代价（jump_cost)会和本级跳转概率加权后累加给父节点。这样，当遍历完成后，首层孩子中最大概率的那个节点就是最优节点。

1. 调整跳转概率的生成，可以控制对手是保守型，还是进攻型。
2. 调整代价传递，会影响到AI对局面的估计。

size_t judge_tree(std::vector<chess_node> & tree)
{
	const size_t total_nodes = tree.size();
	if (total_nodes<2)
		return 0;
	int side = tree[0].side;
	size_t i = total_nodes - 1;
	while (i > 0)
	{
		if (tree[i].side==0)
		{
			float ratio = sqrt((tree[i].jump_cost[1]+1) / (tree[i].jump_cost[0]+1)/ (tree[i].jump_cost[0]+1));
			tree[i].weight = ratio;
		}
		else
		{
			float ratio = sqrt