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]];
}