描述
在一个吝啬的国度里有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

一道恶心人的题，主要是第一次做这种类型的题，整得我头都大了，但是想通了就很简单了。

先是想了一个既浪费时间又浪费空间的写法。

//#include <stdio.h>
//#include <string.h>
//#define MAXSIZE 100001
//
//int map[MAXSIZE][100];
//int toNum[MAXSIZE]; //toNum[i]从i出发可以直接到toNum[i]地点
//int from[MAXSIZE]; //前一个节点位置
//
//void solve(int S)
//{
   
// if (toNum[S] == 1)
// {
   
// return ;
// }
// for (int i = 0; i < S; i++)
// {
   
// for (int j = 0; j < toNum[S]; j++)
// {
   
// if (map[S][j] != from[S])
// {
   
// from[map[S][j]] = S;
// solve(map[S][j]);
// }
// }
// }
// return ;
//}
//
//int main(int argc, const char * argv[])
//{
   
// int M, N, S;
// int a, b;
// scanf("%d", &M);
// 
// while (M--)
// {
   
// memset(map, 0, sizeof(map));
// memset(toNum, 0, sizeof(toNum));
// memset(from, -1, sizeof(from));
// scanf("%d %d", &N, &S);
// 
// for (int i = 1; i < N; i++)
// {
   
// scanf("%d %d", &a, &b);
// map[a][toNum[a]++] = b;
// map[b][toNum[b]++] = a;
// }
// 
// solve(S);
// 
// for (int i = 1; i < N; i++)
// {
   
// printf("%d ", from[i]);
// }
// printf("%d\n", from[N]);
// }
// 
// return 0;
//}

使用了记忆化搜索和递归，最后终于不负所托，既爆内存，又超时，无奈只好另觅奚径了…..

经过一番思索，想到一种感觉上是可行的办法，但是没有绝对的把握，抱着试一试的心态，经过再三琢磨，终于AC了……一看提交记录，所有过的人中，我用得效率是排名前几，内存是最小，满足感油然而生^_^

#include <stdio.h>
#include <string.h>
#define MAXSIZE 100001

int A[MAXSIZE], B[MAXSIZE];
int from[MAXSIZE];  //前一个节点位置
int super[MAXSIZE]; //最前驱是否为S

void solve(int key)
{
    if (key == 0)
    {
        return ;
    }

    int k = 0;
    for (int i = 0; i < key; i++)
    {
        if (super[A[i]] == -1)
        {
            super[B[i]] = -1;
            from[B[i]] = A[i];
        }
        else if (super[B[i]] == -1)
        {
            super[A[i]] = -1;
            from[A[i]] = B[i];
        }
        else
        {
            A[k] = A[i];
            B[k++] = B[i];
        }
    }

    solve(k);
    return ;
}

int main(int argc, const char * argv[])
{
    int M, N, S;
    int a, b;
    scanf("%d", &M);

    while (M--)
    {
        memset(from, -1, sizeof(from));
        memset(super, 0, sizeof(super));
        scanf("%d %d", &N, &S);
        super[S] = -1;
        int key = 0;
        for (int i = 1; i < N; i++)
        {
            scanf("%d %d", &a, &b);
            if (super[a] == -1)
            {
                super[b] = -1;
                from[b] = a;
            }
            else if (super[b] == -1)
            {
                super[a] = -1;
                from[a] = b;
            }
            else
            {
                A[key] = a;
                B[key++] = b;
            }
        }

        solve(key);

        for (int i = 1; i < N; i++)
        {
            printf("%d ", from[i]);
        }
        printf("%d\n", from[N]);
    }

    return 0;
}

如果要追求更加高效，我感觉一定会牺牲掉我的内存的，所以暂时不做这方面考虑了。