【算法笔记】树的遍历 |【PAT A1053】Path of Equal Weight

树的静态写法

在二叉树中，由数据域和指针域组成，左指针指向左子树根结点的地址，右指针指向右子树根结点的地址。对一棵一般意义的树来说，仍然可以保留数据域，而令指针域存放其所有子结点的地址（或者为其开一个数组，存放所有子结点的地址）。但还是建议使用静态方法，用数组下标存放地址。需要事先开一个大小不低于结点上限个数的结点数组：

struct node{
	typename data;
	int child[maxn];
}Node[maxn];

上面的写法由于无法预知子结点个数，所以子结点数组也需要开maxn，最好使用vector，变长数组。

struct node{
	typename data;	//数据域
	vector<typename> child;	//指针域，存放所有子结点的下标
}Node[maxn];

新建结点：

int index=0;
int newNode(int v){
	Node[index].data=v;
	Node[index].child.clear();	//清空子结点
	return index++;		//返回结点下标
}

树的先根遍历

void PreOrder(int root){
	printf("%d ",Node[root].data);
	for(int i=0;i<Node[root].child.size();i++){
		PreOrder(Node[root].child[i]);		//递归访问结点root的所有子结点
	}
}

树的层序遍历

使用一个队列存放结点在数组中的下标，每次取出队首元素访问，子结点加入队列，直到队列为空。

void LayerOrder(int root){
	queue<int> q;
	q.push(root);
	while(!q.empty()){
		int front=q.front;
		printf("%d ",Node[front].data);
		q.pop();
		for(int i=0;i<Node[front].child.size();i++){
			q.push(Node[front].child[i]);
		}
	}
}

如果需要对结点的层号进行求解，只需要在结构体node中增加变量记录层号：

struct node{
	int layer;
	int data;
	vector<int> child;
}

void LayerOrder(int root){
	queue<int> q;
	q.push(root);
	Node[root].layer=0;		//根结点层号为0
	while(!q.empty()){
		int front=q.front;	//队首结点出队
		printf("%d ",Node[front].data);
		q.pop();
		for(int i=0;i<Node[front].child.size();i++){
			int child=Node[front].child[i];		//获取当前结点第i个孩子结点的编号
			// 子结点层号为当前层号+1
			Node[child].layer=Node[front].layer+1;
			q.push(child);
		}
	}
}

从树的遍历看DFS与BFS

1. 深度优先搜索与先根遍历
   对所有合法的dfs求解过程，都可以画成树的形式，例如迷宫，死胡同相当于树的叶结点，岔道口相当于非叶节点，并且对这棵树的dfs遍历就是树的先根遍历。
2. 广度优先搜索与层序遍历
   对所有合法的bfs求解过程，都可以像dfs那样画出一棵树，并且将广度优先搜索问题转换为树的层序遍历问题。

【PAT A1053】Path of Equal Weight

给定一棵树和每个结点权值，求所有从根结点到叶结点的路径，使每个路径上的权值之和等于给定的常数S。如果有多条这样的路径，则按路径非递增的顺序输出。
输入：
20 9 24
10 2 4 3 5 10 2 18 9 7 2 2 1 3 12 1 8 6 2 2
00 4 01 02 03 04
02 1 05
04 2 06 07
03 3 11 12 13
06 1 09
07 2 08 10
16 1 15
13 3 14 16 17
17 2 18 19
输出：
10 5 2 7
10 4 10
10 3 3 6 2
10 3 3 6 2

思路

1. 令结构体node存放结点数据域和指针域，其中指针域使用vector存放所有孩子结点的编号。由于最后输出要按权值从大到小，因此在读入时就事先对每个结点的子结点vector进行排序，这样遍历时就会优先遍历到权值大的子结点。
2. 令int型数组path[MAXV]存放递归过程中产生的路径上的结点编号。进行深度优先遍历，参数有：当前访问的结点编号，当前路径path上的结点个数numNode（即递归层数，每深入一层，path上就会多一个结点），当前路径上的权值和sum。递归过程的伪代码如下：
   • 若sum>S，直接return
   • 若sum=S，说明到当前访问结点index为止，结点权值S已经得到，这时如果结点index为叶结点，则输出path数组中的所有数据；否则return。
   • 若sum<S，说明要求未满足。此时枚举当前访问结点index的所有子结点，对每一个子结点child，先将其存入path[numNode]，在此基础上往下一层递归，下一层的递归参数为child,numNode+1,sum+Node[child].weight。

【在递归的过程中保存路径的方法：】

1. 使用path[i]数组表示路径，path[i]表示第i个结点编号，初值为0的变量numNode作为下标。每向下一层，numNode+1，
2. 使用vector。vector中有push_back()和pop_back()函数，作用分别是将给定元素添加到vector的末尾和将vector末尾元素删除。这样当访问当前结点的子结点时，先把其加入路径，再往下一层递归，最后回溯上来后将前面加入的子结点删除。

代码

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn=110;
struct node{
	int weight;
	vector<int> child;
}Node[maxn];

int n,m,s;		//n-结点总数，m-非叶节点数，s-给出的权值
int path[maxn];	//路径

//当前访问结点为index，numNode为当前路径path上的结点个数
//sum为当前结点权值和
void DFS(int index,int numNode,int sum){
	if(sum>s) return;
	if(sum==s){
		if(Node[index].child.size()!=0) return;	//还没到叶结点，返回上一层
		//到达叶结点，保存路径并输出
		for(int i=0;i<numNode;i++){
			printf("%d",Node[path[i]].weight);	//输出要求最后没有空格，所以要在下面判断，加空格或换行 
			if(i<numNode-1) printf(" ");
			else printf("\n");
		} 
		return;
	}
	//sum<s
	//枚举所有子结点 
	for(int i=0;i<Node[index].child.size();i++){
		int child=Node[index].child[i];	//获取子结点编号
		path[numNode]=child;			//子结点编号存入path路径
		//计算新的权值，进入下一层循环判断 
		DFS(child,numNode+1,sum+Node[child].weight); 
	}
} 

bool cmp(int a,int b){
	return Node[a].weight>Node[b].weight;
}

int main(){
	scanf("%d%d%d",&n,&m,&s);	//n-结点总数，m-非叶节点数，s-给出的权值
	for(int i=0;i<n;i++){
		scanf("%d",&Node[i].weight);	//输入每个结点的权值 
	}
	//确定结点之间的关系
	int id,k,child;		//结点编号，孩子个数,子结点编号 
	for(int i=0;i<m;i++){
		scanf("%d%d",&id,&k);		//结点编号，孩子个数
		for(int j=0;j<k;j++){
			//可以直接拿id，1==01 
			scanf("%d",&child);
			Node[id].child.push_back(child);	//子结点编号放入 
		}
		//对添加的每个子结点按权值递减排序，输出时便是有序的 
		sort(Node[id].child.begin(),Node[id].child.end(),cmp);
	} 
	path[0]=0;		//路径的第一个结点设置为0号
	DFS(0,1,Node[0].weight); 
	return 0;
}