我在微软亚洲研究院面试的一道题，关于二叉树的，欢迎各位讨论

[hinyunsin]

假设有一颗二叉树，已知这棵树的节点上不均匀的分布了若干石头，石头数跟这棵二叉树的节点数相同，石头只可以在子节点和父节点之间进行搬运，每次只能搬运一颗石头。请问如何以最少的步骤将石头搬运均匀，使得每个节点上的石头上刚好为1。

这是前两周我在微软亚洲研究院面试的题目，当时提出了几种解法都被否定了，后来也没怎么想明白，特地拿来论坛讨论，欢迎大家积极讨论。

[Torey]

明天写在不同子二叉树里搬运石头的证明

[wesweeky]

好难啊。。。

[hxlandcym]

构造二叉树比如四级1表示存在，0表示不存在，因为只有两个分支。
10000000
10001000
10100010
11010010
定义数组表示二叉树的数据，比如此列int a[]=new int [15];
for(int i=0;i<4;i+=2)
t[k-1][i]=t[k-1][i]+t[k][i]-1+t[k][i+1]-1;
for(int i=0;i<15;i++)s+=ABS(a[5]);

[hxlandcym]

构造二叉树比如四级1表示存在，0表示不存在，因为只有两个分支。
10000000
10001000
10100010
11010010
定义数组表示二叉树的数据，比如此列int a[]=new int [16];
for(int i=0;i<4;i+=2)
t[k-1][i]=t[k-1][i]+t[k][i]-1+t[k][i+1]-1;
for(int i=1;i<16;i++)s[0]+=ABS(a[i]-1);

[qq675927952]

[Quote=引用 10 楼 dengsf 的回复:]
貌似后序遍历一次即可。
以下未调试，但应够清楚。


C/C++ code

//节点结构
struct node{
int rock_num; //节点原有石头数
node *p_left;
node *p_right;
};

int g_total_move = 0;

//计算本子树需和外部交互的石头数。不足传入，有多传出
void calc_……
[/Quote]

正解！

[疯狂的烤冰]

下面是我的一些想法，是递归的思想：
首先，如果叶子节点的石头多于一个的话，那么就将多出来的转移个父亲节点，这个是必须的，没有其他方法。同理，如果叶子节点的石头为0个的话，就必须将从父亲节点向其移动一个。不管其父亲节点有没有石头，都将其石头的数目减1，就是说其可以是负数，如果是负数，等待从其他节点移动过来石头。
这样的话，如果后序遍历二叉树，那么遍历到每个节点，如果其石头数目大于1，就将多余的移动到其父亲节点，因为其子树已经满足要求了，同理，如果数目小于1，就从其父亲节点减去相应的石头数。由于每一步都是必须的，所以这样的移动的次数应该最少的。
下面是用c++的代码的实现。

#include <iostream>
#include <math.h>
using namespace std;

struct tree			//二叉树的结构
{
	int num;		//石头的数量
	tree *left, *right, *parent;	//左右和双亲节点
};

tree* build(int data[], int n)		
/*建树的函数，data是存石头数量的数组，按从上到下的顺序存储，
如果有空节点则用-1代替，n是节点个数（空节点也算），返回值是树根。（我写的可能不太好，大家可以自己实现）
*/
{
	int i;
	tree* t[999];
	for(i = 0; i < n; i++)
	{
		if(data[i] != -1)
		{
			t[i] = new tree;
			t[i]->num = data[i];
			t[i]->left = t[i]->right = t[i]->parent = NULL;
		}
		else t[i] = NULL;
	}
	for(i = 0; i < n; i++)
		if(t[i])
		{
			if(2*i+1>=n)
				t[i]->left = t[i]->right = NULL;
			else
			{
				t[i]->left = t[2*i+1];
				t[i]->right = t[2*i+2];
			}
			if(i)
				t[i]->parent = t[(i-1)/2];
			else
				t[i]->parent = NULL;
		}
	return t[0];
}

//主要的算法，返回这棵树需要移动几步
int move(tree *t)
{
	int x = 0;
	if(t)
	{
		x += move(t->left)+move(t->right);		//左右子树需要移动的步数
		if(t->parent)
		{
			t->parent->num += (t->num-1);		//从双亲节点移来或移走石头
			x += abs(t->num-1);			//加上本节点需要移动的次数
			t->num = 1;
		}
	}
	return x;
}

int main()
{
	int data[999], n = 0;
	while(cin >> n)
	{
		int i;
		for(i = 0; i < n; i++)
			cin >> data[i];
		tree *t = build(data, n);
		cout << move(t) << endl;
	}
	
	return 0;
}

[Torey]

楼上负数这个概念很好，只是计算部数，根本不用考虑路径

[Torey]

后序遍历
证明：
在一棵只有三个节点的子二叉树里，石头在子树里搬运的步数肯定小于等于子树外面节点搬运的步数。
石头由一个子树移到另一个子数可归结为两步，一为石头移到父节点，二为石头由父节点移到子树结点，所以无论哪颗石头移到哪个节点，总步数总是一定。

[Torey]

#include "string.h"
#include<stdio.h>
#include<vector>
#include <math.h>
#include <iostream>
using namespace std;

struct Number_pearl
{
Number_pearl *FatherPo;
Number_pearl *RightChildPo;
Number_pearl *LeftChildPo;
int ResultNumber;
};
void build(Number_pearl* &t,Number_pearl* &tt,int data[], int n)
{
if (t==NULL)
{
t = new Number_pearl;
t->LeftChildPo=NULL;
t->FatherPo=NULL;
t->RightChildPo=NULL;
t->ResultNumber=data[n];
if (tt!=NULL)
{
t->FatherPo=tt;
}
}
if ((n*2+1)<18)
build(t->LeftChildPo,t,data,n*2+1);
if ((n*2+2)<18)
build(t->RightChildPo,t,data,n*2+2);

}


int Map_Number_pearl(Number_pearl *Po)
{
int x=0;
if (Po->RightChildPo!=NULL)
{
x+=Map_Number_pearl(Po->RightChildPo);
};
if (Po->LeftChildPo!=NULL)
{
x+=Map_Number_pearl(Po->LeftChildPo);
};
if (Po->ResultNumber>1)
{
x+=(Po->ResultNumber-1);
if (Po->FatherPo!=NULL)
(Po->FatherPo)->ResultNumber+=(Po->ResultNumber-1);
Po->ResultNumber=1;
}
else if (Po->ResultNumber<1)
{
x+=(1-Po->ResultNumber);
if (Po->FatherPo!=NULL)
(Po->FatherPo)->ResultNumber-=(1-Po->ResultNumber);
Po->ResultNumber=1;
}
return x;
}
int main()
{
// Number_pearl *Po;
//Number_pearl *Po=new Number_pearl;
int data[18]={3,0,0,3,7,0,0,0,0,1,1,1,1,0,0,0,1,0};
Number_pearl *t=NULL;
Number_pearl *tt=NULL;
build(t, tt, data, 0);
cout << Map_Number_pearl(t) << endl;


return 0;


}

[Oo纳兰筱DoO]

学习一下，见识一下面试题

[迷世书童]

一提微软
大家精神一振啊
哈哈哈哈

[myhaofana]

eh....我想到的是一个最小费用最大流的模型........石头-节点.......呵呵...............

[xr19251]

结贴在哪哦,我想看看 答案~

[ffee123123]

这是我想到的一个思路，提供大家一起讨论
i)后根遍历这个二叉树，给每个以某一节点为根的子树的根节点赋一个权值，当这个子树差一个石头时，为-1，多一个石头时为1，不差的时候为0；
ii）找出权值最大的节点node，如果权值为0，结束；否则，将它上面的石头搬运到以它为根的子树的节点上去，将多余的石头移动到父节点，同时修改父节点的权值，并且将以节点node为根的子树逻辑删除。
iii)转回去执行ii

[遥望未来_cheerup]

看来没有标准！！

[cug_fish_2009]

此题思路就是树形DP。

[wangyangkobe]

编程之美上的

[Debugcool]

这个可以用网络流来做~

第一步，LCA求出树中任意两点的最近公共祖先，那么可以知道任意两点之间的距离。

第二步，建立网络流模型，有多余石子的点在一边，没有石子的在一边，中间连边，容量为剩余石子数，费用为第一步求出的最短距离，然后最小费用流求解~

[pingdan32]

哈哈~~~在

中间的 ][ 之间插入插入代码即可~~~~~

[Quote=引用 49 楼 2608 的回复:]
kao~~~, 到底怎么插入代码啊！！
[/Quote]

[software_artisan]

首先是二叉树，其次是每结点1个。
那么解决方法很明确了，遇到一个石子多于1的节点，就判断此节点下的两个节点下是否存在石子总数小于节点数的，如果有，则标志一个移动方向。如果是大于，则标志为向上移动。等于则无需标记。直至达到末端，那么所有的移动方向都标记出来了。从根节点开始按向上优先回溯，然后按标记方向搬运即可。