SCAU 2011 校赛 10307 Trees and Numbers

10307 Trees and Numbers

1.题意：
一个Case表示森林，森林有一棵至多棵树不等，每一棵树代表着一个素数，而森林代表着所有数经过某种结合产生的一个值 N。如果我给这森林加一个根成为一棵树，那么这个根节点表示的就是第N个素数，具体点来说：
2 是第一个素数，我们用一个节点表示它，在这个节点之上我再加一个节点，由于前面这个节点表示的N为2，所以新加的这个节点表示第 2 个素数即 3，在表示 3 的这个节点之上我再加一个新的节点那么就表示第 3 个素数即 5，在 5 之上再加一个新的节点，那么这时表示的是第 5 个素数即 11，不再增加节点的话，那么这棵树就表示一个值 11。
如果森林有两棵以上的数，那么这个森林表示的值 M 为各棵树表示的值相乘得到的结果。这时如果往森林里增加新节点表示为根将所有的树连接成一棵树，那么这个新节点表示的值为第 M 个素数，整棵新树表示的值同样也为第 M 个素数

2.解题思路：
首先，筛素数。根据题目给出的范围，筛出50000以为的素数，存储在数组Prime中，最好根据题目的要求将下标定为第几个素数，比如说 Prime[1] = 2, Prime[2] = 3；
然后，建树。根据题目输入的形式，可以用一个数组Parent存储 i 的双亲节点的“数组下标地址”为Parent[i], 考虑到孩子数目的不确定数，声明结构体，用孩子链表存储孩子节点，并且每个节点都要声明一个变量存储其表示的素数（具体声明可以看《数据结构》（严慧敏版）136页）；
最后，遍历计算。首先要找到树根，如果数不止一棵的话，那么这片森林所代表的值为所有的树的值相乘得到的值，至于计算每棵树表示的值，采用深度优先遍历即可

Description

Can you find the rule of these equations?
Let me explain for you. There are only 3 definitions:
Every Tree represent a prime integer (prime integer is an integer that can only divide by 1 and itself. e.g. 2,3,5,7 etc.).
A forest (one or more trees) represents a integer which is the product of trees.
If we add a root for a forest (Let n to be the integer it represent) to build a tree, then this new tree represent the n-th prime integer.
For example , 2 is the first prime integer , we use one node to represent it , and 3 is the second , so we add a root to 2 , it become 3. 
Then add a root to 3 , we get the third prime ——5. If we add a root to 5? We get the fifth prime, which is 11. Also, while combine 3 and 5 ,
 we will get 15 since 15=3*5 . That is why 11 and 15 represent that in the figure.

Figure 2: 15=3*5 and 23 is the 9-th prime integer.
Now, give you a tree, can you find the integer it represents?

输入格式

The Input will contain multiple cases.
The first line contains an integer T, the number of test cases.
Then T cases follow.
The first line of each case, is a integer n(n>0) , that represents the number of nodes in the forest.
After that, there will be one line contains n integers. The i-th integer ai means that the father node of 
the i-th node is ai (0<=ai<=n) . And if ai=0, it just means that i-th node is a root of tree (0 is not a node).
You can assume that all this can exactly build a forest, and cases like:
2
2 1
is invalid and will not appear.

输出格式

For each case, output the answer in one line.
You may assume that all the answers are less than 50000.

输入样例

7
1
0
4
0 1 2 3
5
0 1 0 3 4
5
0 1 1 1 2
6
0 0 0 3 4 4
7
0 0 5 2 2 4 1
6
0 1 1 1 1 1

输出样例

2
11
15
37
68
69
131

提示

The 2-7th sample is in the figure 1.

作者

admin

#include<stdio.h>
#include<string.h>
#include<malloc.h>
#define MAXN 50000
#define MAX_N 5200

typedef struct child{
//孩子节点 
    int ads; //此节点的下标 
    struct child *nextchild; //指向其兄弟 
}child;

typedef struct Tree{
    int num, value; //num 表示其孩子的个数，value 表示这棵树表示的素数值 
    struct child *firstchild; //指向其第一个孩子节点 
}Tree;

typedef struct forest{
    int num; //只是表示这片森林一共有几个节点，这个结构体可以省略 
    Tree note[MAX_N];
}forest;

forest equation;
int prime[MAXN/2], parent[MAXN+2];

int store_prime()
{//筛出 50000 以内的素数存储到prime数组中，返回素数的个数 
    int i, j, cnt = 1;
    memset(prime, 0, sizeof(prime));
    memset(parent, 0, sizeof(parent));
    parent[0] = parent[1] = 1;
    for(i=2; i<MAXN+2; ++i)
    {
        if(!parent[i])
        {
            prime[cnt++] = i;
            for(j=i; j<MAXN+2; j += i)
            parent[j] = 1;
        }
    }
    return cnt;
}

void init_equation()
{//初始化所有的节点 
    int i;
    for(i=1; i<=equation.num; ++i)
    {
        equation.note[i].num = 0;
        equation.note[i].value = 2;
        equation.note[i].firstchild = NULL;
    }
    return;
}

void insert(int cur, int elem)
{//将节点 elem 插入到其双亲节点 cur 的孩子链表中 
    int i, n;
    child *str = NULL, *stp = NULL;
    n = equation.note[cur].num;
    stp = str = equation.note[cur].firstchild;
    for(i=1; i<n; ++i)
        stp = stp->nextchild;
    str = (child *)malloc(sizeof(child));
    str->nextchild = NULL, str->ads = elem;
    if(n == 0) equation.note[cur].firstchild = str;
    else stp->nextchild = str;
    ++equation.note[cur].num;
    return;
}
/* 
void Print(int n)
{//中间打印的测试函数，忽略 ~~ 
    int i, j, temp;
    child *str = NULL;
    for(i=1; i<=n; ++i)
    {
        printf("%d [%d] ", parent[i], i);
        temp = equation.note[i].num;
        str = equation.note[i].firstchild;
        if(temp != 0 )
        do
        {
            printf("%d ", str->ads);
            str = str->nextchild;    
        }while(--temp);
        printf("\n");
    }
}
*/

int Traverse(int cur)
{//典型的深度查找，计算一棵树所代表的的素数值 
    int i, j, n, temp, k;
    child *str = equation.note[cur].firstchild;
    n = equation.note[cur].num;
    if(str == NULL) return equation.note[cur].value;
    for(i=1, k=1; i<=n; ++i)
    {
        k *= Traverse(str->ads);
        str = str->nextchild;    
    }
    return equation.note[cur].value = prime[k];
}

int main()
{
//    freopen("input.txt", "r", stdin);
    int i, j, t, T, n, point, k, flag, sum, num;
    num = store_prime();
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        equation.num = n;
        sum = 1;
        init_equation();
        for(i=1; i<=n; ++i)
        {//parent数组存储指向 i 节点的 双亲的地址下标  
            scanf("%d", &parent[i]);
            if((point = parent[i]) != 0)
                insert(point, i);
        }
        for(i=1; i<=n; ++i)
        {
            if(parent[i] == 0)
            {
                Traverse(i);
                sum *= equation.note[i].value;
            }
        }
        printf("%d\n", sum);
    }
    return 0;
}