深入虎穴
7-2 深入虎穴 (30 分)
著名的王牌间谍 007 需要执行一次任务,获取敌方的机密情报。已知情报藏在一个地下迷宫里,迷宫只有一个入口,里面有很多条通路,每条路通向一扇门。每一扇门背后或者是一个房间,或者又有很多条路,同样是每条路通向一扇门…… 他的手里有一张表格,是其他间谍帮他收集到的情报,他们记下了每扇门的编号,以及这扇门背后的每一条通路所到达的门的编号。007 发现不存在两条路通向同一扇门。
内线告诉他,情报就藏在迷宫的最深处。但是这个迷宫太大了,他需要你的帮助 —— 请编程帮他找出距离入口最远的那扇门。
输入格式:
输入首先在一行中给出正整数 N(<105),是门的数量。最后 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,即为最深结点
}