NYOJ－20－吝啬的国度

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

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