POJ 1694 An Old Stone Game

题目：

有一个古老的石头游戏，该游戏基于任意一棵树T，游戏的目标是在树T的根节点上放一颗石头，游戏的规则如下：

1 游戏开始前，玩家先将K个石头放入桶中。

2 在游戏的每一步，玩家从桶中拿一颗石头放到树的一个空的叶子节点上。

3 当一个节点p的所有r个子节点都有一个石头，则移去r个子节点上的石头，然后将一个石头放到节点p上。剩下的r-1个石头重新放到桶中重复使用。

如果玩家根据以上规则放置石头，并最终在根节点上放置一颗石头，则赢得游戏。

现在的任务是求出游戏开始时，石头数K的最小值，使得玩家能在给定树的情况下赢得游戏。

输入：

第一行输入测试用例的个数，每个测试用例是一颗树的描述。第二行开始输入每棵树的描述。

每棵树有N个节点，N<200，节点标号为1，2，...N，每个节点可以有任意个子节点，根节点标号为1,。树的描述第一行为节点数N，第二行开始按照节点标号顺序描述N个节点的子节点，每行第一个数为标号p，第二个数为子节点数r，如果r不为0，接下来为r个子节点的标号。

输出：

对每棵树，输出石头数的最小值。

解题思路：

要求一棵树的最小石头数，先求根节点下各个子树的最小石头数。

设根节点的最小石头数为result，根节点有r个子节点，先求出r个子节点的最小石头数，得到r个数，将这r个数按照从大到小排列，得到result1，result2，。。。result r，

令result=result1，则剩余数remain=result1-1，从result2开始遍历到resultr，如果remain>=result i，则remain足够，如果remain<result
i，则remain不足够，需要加上result i-remain个，即result=result+（result i-remain），remain=remain+（result
i-remain）；每处理一个数后remain减1（因为每棵子树需要一个石头），处理完所有r个数后，就得到以根节点为根的最小石头数result了。

求子树的最小石头数时可以采用上述过程递归求解。

代码：

#include<stdio.h>
#include<stdlib.h>

typedef struct Node
{
int num;
struct Node* child;  //孩子节点
struct Node* sibling;//兄弟节点
} Node;

Node* root;

Node* newNode()
{
Node* p;
p = (Node*)malloc(sizeof(Node));
p->child=NULL;
p->sibling=NULL;
return p;
}

void buildTree()
{
int nodeCount, i,j,num,childCount;
Node *p, *prior;
Node** list;
scanf("%d", &nodeCount);
list = (Node**)malloc(sizeof(Node*)*nodeCount);
for(i=0; i<nodeCount; i++) list[i]=NULL;
for(i=0; i<nodeCount; i++)
{
//读取节点编号
scanf("%d", &num);
if(list[num-1]==NULL) list[num-1]=newNode();
list[num-1]->num=num;

//读取子节点
scanf("%d", &childCount);
for(j=0; j<childCount; j++)
{
p = newNode();
scanf("%d", &p->num);
list[p->num-1]=p;
if(j==0) list[num-1]->child = p;
else prior->sibling = p;
prior = p;
}
}

root = list[0];
}

int cmp(const void * a, const void * b)
{
return (*(int *)b-*(int *)a);
}

//求最少的石头数
int mininumStones(Node *p)
{
int result=0,childCount=0,remain;
Node *temp;
int *list,i;
//计算子节点数目
if(p->child != NULL)
{
childCount++;
temp = p->child;
while(temp->sibling != NULL)
{
childCount++;
temp = temp->sibling;
}
}

if(childCount == 0) return 1; //叶子节点
else
{
list=(int *)malloc(sizeof(int)*childCount);
temp = p->child;
//计算每个子树需要的石头数
for(i=0; i<childCount; i++)
{
list[i]=mininumStones(temp);
temp=temp->sibling;
}
//排序
qsort(list, childCount, sizeof(int), cmp);
result = list[0];
remain = list[0]-1;
for(i=1; i<childCount; i++)
{
if(remain<list[i]) {result++; remain++;}
remain--;
}

return result;
}

}

int main()
{
int testcase,i;
scanf("%d", &testcase);
for(i=0; i<testcase; i++)
{
buildTree();
printf("%d\n",mininumStones(root));
}
return 0;
}