nyoj ACM:吝啬的国度（bfs）

吝啬的国度
时间限制：1000 ms | 内存限制：65535 KB
难度：3
描述
在一个吝啬的国度里有N个城市，这N个城市间只有N-1条路把这个N个城市连接起来。现在，Tom在第S号城市，他有张该国地图，他想知道如果自己要去参观第T号城市，必须经过的前一个城市是几号城市（假设你不走重复的路）。
输入
第一行输入一个整数M表示测试数据共有M(1<=M<=5)组
每组测试数据的第一行输入一个正整数N(1<=N<=100000)和一个正整数S(1<=S<=100000)，N表示城市的总个数，S表示参观者所在城市的编号
随后的N-1行，每行有两个正整数a,b(1<=a,b<=N)，表示第a号城市和第b号城市之间有一条路连通。
输出
每组测试数据输N个正整数，其中，第i个数表示从S走到i号城市，必须要经过的上一个城市的编号。（其中i=S时，请输出-1）
样例输入
1
10 1
1 9
1 8
8 10
10 3
8 6
1 2
10 4
9 5
3 7
样例输出
-1 1 10 10 9 8 3 1 1 8

思路：
求前驱节点 ， 或者 求最小步数 ， 考虑 bfs 广度优先搜索

此地用 邻接链表存储图。
用 队 列 实现 bfs，没出一个节点，判断其以前有没有将他的子节点都存储到队列中了（根据flag），如果有，则直接pop（）,并跳过改点，否则将其子节点都push（）到队列中去。
邻接链表的头指针都存储在一个数组中，数组类型为struct head。其中f存储自己的前驱节点，flag表示自己之前是否被访问过，p为指针。

#include<stdio.h> 
#include<malloc.h>
struct node{
    int i;
    struct node* p;
};

struct head{
    int f;
    int flag;
    struct node* p;
};

void init(int* a);
void push(int* a,int S);
int pop(int* a);

int main()
{
    int M,N,S;
    int u,v;
    int i=0,j=0,k=0;
    int* a=0; 
    struct head* h=0; 
    struct node* q=0;
    scanf("%d",&M);
    for(i=1;i<=M;i++)
    {
        scanf("%d%d",&N,&S);
        h=(struct head*)malloc(sizeof(struct head)*(N+1));
        a=(int*)malloc(sizeof(int)*(2*N+1));
        for(j=1;j<=N;j++)
        {
            h[j].flag=0;
            h[j].f=0;
            h[j].p=NULL;
        }

        for(j=1;j<=N-1;j++)
        {
            scanf("%d%d",&u,&v);
            q=(struct node*)malloc(sizeof(struct node)*1);
            q->i=v;
            q->p=h[u].p;
            h[u].p=q;

            q=(struct node*)malloc(sizeof(struct node)*1);
            q->i=u;
            q->p=h[v].p;
            h[v].p=q;
        }
        h[S].f=-1;

        init(a);
        push(a,S);
        k=pop(a);
        while(k!=-1)
        {
            if(h[k].flag!=0)
            {
                k=pop(a);
                continue;
            }

            h[k].flag=1;
            q=h[k].p;

            while(q!=NULL)
            {
                push(a,q->i);
                if(h[q->i].f==0)
                {
                    h[q->i].f=k;
                }
                q=q->p;
            }
            k=pop(a);
        }

        for(j=1;j<=N;j++)
        {
            printf("%d ",h[j].f);
        }
        printf("\n");
    }

    return 0;
}

void init(int* a)
{
    a[0]=1;
    a[1]=2;
}
void push(int* a,int S)
{
    a[a[1]]=S;
    a[1]++;
}
int pop(int* a)
{
    if(a[0]==a[1]-1)
        return -1;

    a[0]++;
    return a[a[0]];
}