1053 Path of Equal Weight (30 分) 全网最细 题目详解 翻译 完整代码 PAT甲级真题解析

预备知识：

1. C++ STL vector
2. C++ STL sort()函数

题目翻译：

若给定一个根结点为R，树节点为T(i)，树节点的权值为W(i)的非空树。从根结点R到叶子结点L的权重被定义为：从R到任意叶子结点L的路径所经过的所有节点的权重之和。现在给定任意一个加权树，你需要找到与给定权值相等的从根节点到叶子结点的路径权重。
如下图的树：对于每个节点，上面的数字是节点ID（两位数字），下面的数字是该节点的权重。设给定的数字是24，则该树存在4条具有相同权重的不同路径：{10 5 2 7}，{10 4 10}，{10 3 3 6 2} 和 {10 3 3 6 2}，对应图中的红色边。

难点单词：

weighted 权重

输入格式：

每个输入文件包含一个测试用例。对于每个测试用例：
「第一行」给出三个数：1. 树的总结点个数 N（0<N≤100）；2. 树中非叶子结点个数 M（<N）；3. 需要匹配的目标权值 S（0<S<2^​30）
「第二行」给出 N 个正整数 W(i)（<1000）对应于每个树结点 T(i) 的权重
「往后M行」以 “ ID K ID[1] ID[2] … ID[K] ”的格式给出。其中ID表示给定非叶节点的两位编号，K是该结点子结点的个数，后跟该节点的全部子结点的两位ID号。为了简单起见，将根结点的ID设置为00。

输出格式：

对于每个测试用例，以非递增顺序打印权重为S的所有路径。每条路径从根到叶依次占据一行打印。所有数字必须用空格隔开，行尾不能有多余的空格。
注：若存在序列A「10 4 6」，序列B「10 3 6」，则「序列A」>「序列B」

输入样例：

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. 建树
   a. 用何种方法建树？如何存储子结点 ？
   b. 直接开始遍历吗？是否还需要做其他操作？
2. 遍历
   a. 如何递归？递归的递归边界、递归正常退出、递归的循环逻辑是怎样？
   b. 何时输出？如何保存和输出？

逻辑梳理：

先建读取数据并建“树”：

1. 定义树的结构：查看题目的输入样例后我们发现，结点给出的顺序是无规律的，所以无法采用常规链表建树。很容易想到用二维结构体数组来存储每个节点的信息。（结点下标对应一维数组下标，结点孩子对应二维数组的值）（注：用C++ STL中的 vector 代替二维数组更为方便。）

   定义出结点的结构体信息：

   struct node {
       int weight;
       vector<int> child;
   } Node[MAXN];
   

2. 读取输入数据：

   	int n, m, S;
   	const int MAXN = 110;
   	
       scanf("%d%d%d", &n, &m, &S); // 结点总数 非叶子结数 目标权值
       for(int i = 0; i < n; i++) { // 循环读入
           scanf("%d", &Node[i].weight); // T(i)结点权值
       }
       int id, k, child; // 当前结点ID 当前结点的子结点数 当前结点的某个孩子结点
       for(int i = 0; i < m; i++) { // 共m个结点
           scanf("%d%d", &id, &k);
           for(int j = 0; j < k; j++) { // 当前结点共k个子结点
               scanf("%d", &child);
               Node[id].child.push_back(child); // 将孩子结点的ID压入vector
           }
           //!!!注意此处有一步额外操作（见第3步）
           //!!!注意此处有一步额外操作（见第3步）
           //!!!注意此处有一步额外操作（见第3步）
       }
   

3. 给结点按照权值从大到小排序。为什么要这样做？因为题目要求在输出的时候，对于同样的序列，结点权值大的要优先输出。如果我们在存储的时候就事先从大到小排序，那么在顺序遍历数组的时候，也将会是优先访问到权值较大的结点，从而达成题目的输出条件。要使用C++的STL比较结构体内的数据大小，我们还需要重载一下排序函数。

   // 重载对比函数cmp
   bool cmp(int a, int b) {
       return Node[a].weight > Node[b].weight;
   }
   //在第2步代码中结束位置插入的排序函数
   sort(Node[id].child.begin(), Node[id].child.end(), cmp);
   

接下来递归遍历结点，按照规则输出序列，考虑递归遍历的逻辑：

int path[MAXN]; // 存储遍历过的结点ID
// 递归函数（结点ID 当前分枝已遍历的结点个数 权重累加和）
void DFS(int index, int numNode, int sum){} 

1. 递归失败退出：累加权重值S大于目标权重值，不满足条件，退出递归；

   if(sum > S) return;
   

2. 递归正常退出：当累加权重值S等于目标权重值且当前结点是叶子结点时（无子结点），满足条件，输出并退出递归。

   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;
   }
   

3. 递归循环逻辑：递归访问结点，累加经过结点的权重值保存在S中，将结点编号保存在数组中；

       for(int i = 0; i < Node[index].child.size(); i++) {
           int child = Node[index].child[i];
           path[numNode] = child;
           DFS(child, numNode + 1, sum + Node[child].weight);
       }
   

最后附上完整的参考代码

参考代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 110;
struct node {
    int weight;
    vector<int> child;
} Node[MAXN];
bool cmp(int a, int b) {
    return Node[a].weight > Node[b].weight;
}
int n, m, S;
int path[MAXN]; // 存储遍历过的结点ID

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;
    }
    for(int i = 0; i < Node[index].child.size(); i++) {
        int child = Node[index].child[i];
        path[numNode] = child;
        DFS(child, numNode + 1, sum + Node[child].weight);
    }
}

int main() {
    scanf("%d%d%d", &n, &m, &S); // 结点总数 非叶子结数 目标权值
    for(int i = 0; i < n; i++) { // 循环读入
        scanf("%d", &Node[i].weight); // T(i)结点权值
    }
    int id, k, child; // 当前结点ID 当前结点的子结点数 当前结点的某个孩子结点
    for(int i = 0; i < m; i++) { // 共m个结点
        scanf("%d%d", &id, &k);
        for(int j = 0; j < k; j++) { // 当前结点共k个子结点
            scanf("%d", &child);
            Node[id].child.push_back(child); // 将孩子结点的ID压入vector
        }
        sort(Node[id].child.begin(), Node[id].child.end(), cmp);
    }
    path[0] = 0;
    DFS(0, 1, Node[0].weight);
    return 0;
}

全部通过