7-2 深入虎穴 （30 分)

深入虎穴

7-2 深入虎穴 （30 分)
著名的王牌间谍 007 需要执行一次任务，获取敌方的机密情报。已知情报藏在一个地下迷宫里，迷宫只有一个入口，里面有很多条通路，每条路通向一扇门。每一扇门背后或者是一个房间，或者又有很多条路，同样是每条路通向一扇门…… 他的手里有一张表格，是其他间谍帮他收集到的情报，他们记下了每扇门的编号，以及这扇门背后的每一条通路所到达的门的编号。007 发现不存在两条路通向同一扇门。
内线告诉他，情报就藏在迷宫的最深处。但是这个迷宫太大了，他需要你的帮助 —— 请编程帮他找出距离入口最远的那扇门。
输入格式：
输入首先在一行中给出正整数 N（<10​5​​），是门的数量。最后 N 行，第 i 行（1≤i≤N）按以下格式描述编号为 i 的那扇门背后能通向的门：
K D[1] D[2] ... D[K]
其中 K 是通道的数量，其后是每扇门的编号。
输出格式：
在一行中输出距离入口最远的那扇门的编号。题目保证这样的结果是唯一的。
输入样例：
13
3 2 3 4
2 5 6
1 7
1 8
1 9
0
2 11 10
1 13
0
0
1 12
0
0
输出样例：
12

结构选择

一个门后可能有很多门，显然是一个树的结构。我们要做的事是输出深度最高的结点
那么要考虑的是用什么结构存储这棵树，我们根据输入考虑

K D[1] D[2] ... D[K]

忽略第一行，第i行表示的是编号为i的门后有k条路，分别通向编号为D[1] D[2] … D[K]的门
题目并没有说明第一个门一定是1号。事实上，在可通向的门中，未出现的那个编号就是第一个门
我们可以通过邻接矩阵来表示某扇门能通向哪些门，可以通过行列遍历来实现整棵树的遍历。但弊端很明显，给出的层数可以很大，但一扇门后面并不会有太多路，导致实际上是稀疏矩阵，开辟整个空间会导致大量空间的浪费。
为了避免浪费，我们可以定义一个结构体数组，结构体包括数据域和指针域，数据域存储K，指针域指向新的结构体，新的结构体数据域为D[1]，D[1]的指针域再指向D[2]…一直到D[K]。
但是，这个类似单链表的结构在操作上有一定难度（指针操作比较复杂），考虑到指针和数组名同为地址，不如将结点指针域指向一个数组，这个数组的长度为结点数据域的值K。

代码实现

结构定义

//结点定义
typedef struct {
	int num;	//门后面的门的总数
	int *p;		//指向门之后的门的编号所组成的数组
}node;

然后在主函数中创建实例

int main() {
	node *a;	//存储所有门的信息（整棵树）
	int n;		//一共n扇门，读入n
	cin >> n;	
	a = new node[n = 1];
	return 0;
}

数据读入

首先是一个外层循环，用于读入每扇门，即读入k。再嵌套一个内层循环，读入每扇门后的所通向门的信息。注意题目中门的编号从1-n，因此我们输入的时候

	for (int i = 1 i <= n; i++) {
		cin >> a[i].num;
		for (int j = 0; j < a[i].num;j++) {
			cin >> a[i].p[j];
		}
	}

但这段代码是不正确的，因为我们指定了p，却没有给他分配空间，所以现在的p是个野指针。
此外，我们需要考虑，如果输入的门后面的路为0，则不需要分配空间，我们将其设置为空指针，避免野指针的非法访问。

	for (int i = 1; i <= n; i++) {
		cin >> a[i].num;
		if (a[i].num != 0) {	//如果不为0，分配空间并循环输入
			a[i].p = new int[a[i].num];	//为p数组分配空间
			for (int j = 0; j < a[i].num; j++) {
				cin >> a[i].p[j];
				doors[a[i].p[j]] = true;
			}
		}
		else {		//如果门后没有路，就将指针置空
			a[i].p = NULL;
		}
	}

然后，为了能够在输入结束后得到第一扇门，需要在输入前申请一个数组并初始化，在输入这扇门所通向的门的时候，改变通向门对应编号（下标）的值。在输入结束的时候遍历这个数组，输出没有输入到的门的编号。

//循环输入n扇门，并返回第一扇门的编号，即数组下标
int input(node *a, int n) {
	int result = 0;		//用于存储第一扇门的编号（下标）并输出
	// 设置数组查找第一扇门，分配空间并初始化
	bool *doors;		
	doors = new bool[n + 1];
	for (int k = 1; k <= n; k++) {
		doors[k] = false;
	}
	//循环输入
	for (int i = 1; i <= n; i++) {
		cin >> a[i].num;
		if (a[i].num != 0) {	//如果不为0，分配空间并循环输入
			a[i].p = new int[a[i].num];	//为p数组分配空间
			for (int j = 0; j < a[i].num; j++) {
				cin >> a[i].p[j];
				doors[a[i].p[j]] = true;
			}
		}
		else {		//如果门后没有路，就将指针置空
			a[i].p = NULL;
		}
	}
	//遍历数组root,为false的门为第一扇门
	for (int m = 1; m <= n; m++) {
		if (doors[m] == false) {
			result = m;
			break;
		}
	}
	return result;        
}

层次遍历

通过输入我们的树已经建立起来了，那么利用层次遍历就可以得到最深的结点了

//r为第一扇门编号，从a[r]开始进行遍历，返回最后一个，即最深的结点编号
int level(node *a, int r) {
	queue<int> q;
	int temp;	//当前队头，即当前门的编号
	q.push(r);
	//树的层次遍历，当前层一个个遍历，将子结点入队
	while (!q.empty()) {
		temp = q.front();	//得到队头再出队
		q.pop();
		if (a[temp].num != 0) {		//编号temp的门后还有门，就将他们入队
			for (int i = 0; i < a[temp].num; i++) {
				q.push(a[temp].p[i]);
			}
		}
	}
	return temp;	//层次遍历，最后一个值覆盖temp，即为最深结点
}

主函数

主函数就相对简单，之前的实例化后再加上循环输入和层次遍历，输出层次遍历得到的值就行。

#include <iostream>
#include <queue>

using namespace std;

//结点定义
typedef struct {
	int num;	//门后面的门的总数
	int *p;		//指向门之后的门的编号所组成的数组
}node;

int input(node *a, int n);
int level(node *a, int r);

int main() {
	node *a;	//存储所有门的信息（整棵树）
	int root;	//root表示第一扇门
	int n;		//一共n扇门，读入n
	cin >> n;	
	a = new node[n + 1];	//分配空间
	root = input(a, n);		//输入每扇门信息，得到第一扇门
	cout << level(a, root);	//从第一扇门a[root]开始遍历，输出最后一个即最深结点
	return 0; 
}

//循环输入n扇门，并返回第一扇门的编号，即数组下标
int input(node *a, int n) {
	int result = 0;		//用于存储第一扇门的编号（下标）并输出
	// 设置数组查找第一扇门，分配空间并初始化
	bool *doors;		
	doors = new bool[n + 1];
	for (int k = 1; k <= n; k++) {
		doors[k] = false;
	}
	//循环输入
	for (int i = 1; i <= n; i++) {
		cin >> a[i].num;
		if (a[i].num != 0) {	//如果不为0，分配空间并循环输入
			a[i].p = new int[a[i].num];	//为p数组分配空间
			for (int j = 0; j < a[i].num; j++) {
				cin >> a[i].p[j];
				doors[a[i].p[j]] = true;
			}
		}
		else {		//如果门后没有路，就将指针置空
			a[i].p = NULL;
		}
	}
	//遍历数组root,为false的门为第一扇门
	for (int m = 1; m <= n; m++) {
		if (doors[m] == false) {
			result = m;
			break;
		}
	}
	return result;
}

//r为第一扇门编号，从a[r]开始进行遍历，返回最后一个，即最深的结点编号
int level(node *a, int r) {
	queue<int> q;
	int temp;	//当前队头，即当前门的编号
	q.push(r);
	//树的层次遍历，当前层一个个遍历，将子结点入队
	while (!q.empty()) {
		temp = q.front();	//得到队头再出队
		q.pop();
		if (a[temp].num != 0) {		//编号temp的门后还有门，就将他们入队
			for (int i = 0; i < a[temp].num; i++) {
				q.push(a[temp].p[i]);
			}
		}
	}
	return temp;	//层次遍历，最后一个值覆盖temp，即为最深结点
}