nyoj20(吝啬的国度)

吝啬的国度

时间限制： 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

解题思路：

1.实际是关于图的题目，题目给出顶点的个数和边数（顶点-1），然后去构造一个图

2.要求输出当前顶点的上一个顶点，如果随便找一个点遍历得出的结果是错误的。

   因为找到一个点的prev不一定是主人公走的路，因此要在主人公所在的顶点开始遍历

3.如何记录当前顶点的前一个顶点? 无论深搜还是广搜每一次遍历都是根据上一层的顶点向下遍历

   所以只要使用数组保存当前顶点的前驱就可以了，比如3的前一个顶点为2，那么prev[3] = 2

采用自定义链表并结合深搜时间较短

使用printf和scanf以及自定义链表

/*88ms*/
#include <memory.h>
#include <stdio.h>
using namespace std;

struct Node
{
	int x;
	struct Node* next;
};
Node *ver[100002];
int pre[100002];
char flag[100002];
int n, sx;

void ins(Node* &head, int x)
{
	Node* cur = new Node;
	cur->x = x;
	cur->next = head;
	head = cur;
}

void dfs(int x)
{
	flag[x] = 1;
	int n;
	for (Node *cur = ver[x]; cur != NULL; cur = cur->next)
	{
		n = cur->x;
		if (!flag[n])
		{
			flag[n] = 1;
			pre[n] = x;
			dfs(n);
		}
	}
}

int main()
{
    int x, y, m;
    scanf("%d", &m);
    while (m-- > 0)
    {
        memset(flag, 0, sizeof(flag));

        scanf("%d%d", &n, &sx);
        for (int i=0; i<n; ++i)
        	ver[i] = NULL;
        for (int i=1; i<n; ++i)
        {
        	scanf("%d%d", &x, &y);
        	ins(ver[x], y);
        	ins(ver[y], x);
        }
        dfs(sx);

        pre[sx] = -1;
        printf("%d", pre[1]);
        for (int i=2; i<=n; ++i)
        {
        	printf(" %d", pre[i]);
        }
        putchar('\n');
    }
	return 0;
}
        

利用STL队列和容器较慢

使用cin和cout

/*164ms*/
#include <iostream>
#include <memory.h>
#include <stdio.h>
#include <queue>
#include <vector>
using namespace std;

vector<int> ls[100002];
int pre[100002];
char flag[100002];
int n, sx;

/*void bfs()
{
    queue<int> q;
    vector<int>::iterator it, itEnd;
    int cur;
    flag[sx] = 1;
    q.push(sx);
    while (!q.empty())
    {
        cur = q.front();
        q.pop();
        it = ls[cur].begin();
        itEnd = ls[cur].end();
        for (; it != itEnd; ++it)	// 访问当前相邻的顶点
        {
            if (!flag[*it])
            {
                flag[*it] = 1;
                q.push(*it);
                pre[*it] = cur;		// 保存前一个城市
            }
        }
    }
}*/

void dfs(int v)
{
	flag[v] = 1;
	vector<int>::iterator it, itEnd;
	it = ls[v].begin();
	itEnd = ls[v].end();
	int cur;
	for (; it != itEnd; ++it)	//依次访问相邻的顶点
	{
		cur = *it;
		if (!flag[cur])			// 未被访问
		{
			pre[cur] = v;		// 保存前一个城市
			dfs(cur);			// 继续访问下一个
		}
	}
}

int main()
{
    int x, y, m;
    cin>>m;
    while (m-- > 0)
    {
        memset(flag, 0, sizeof(flag));

        cin>>n>>sx;
        for (int i=1; i<=n; ++i)
        	ls[i].clear();
        for (int i=1; i<n; ++i)
        {
        	cin>>x>>y;
        	ls[x].push_back(y);
        	ls[y].push_back(x);
        }
        dfs(sx);	// 从所在位置搜索
        //bfs();
        pre[sx] = -1;
        cout<<pre[1];
        for (int i=2; i<=n; ++i)
        {
        	cout<<" "<<pre[i];
        }
        cout<<endl;
    }
	return 0;
}