PAT 甲级 树（二）
作者：互联网
PAT 甲级 树（二）
AVL两道题的思路待补充，红黑树待写！！！
二叉搜索树最后两层节点数量
题目
二叉搜索树 (BST) 递归定义为具有以下属性的二叉树：
若它的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
它的左、右子树也分别为二叉搜索树
将一系列数字按顺序插入到一个空的二叉搜索树中，然后，请你计算结果树的最低两层的结点个数。
输入格式
第一行包含整数 N，表示插入数字序列包含的数字个数。
第二行包含 N 个整数，表示插入数字序列。
输出格式
以如下格式，在一行中，输出结果树的最后两层的结点数：
n1 + n2 = n
n1 是最底层结点数量，n2 是倒数第二层结点数量，n 是它们的和。
数据范围
1≤N≤1000,
−1000≤ 插入数字 ≤1000。
输入样例：
9
25 30 42 16 20 20 35 -5 28
输出样例：
2 + 4 = 6
思想
1、如何根据序列插入二叉搜索树中
void insert(int& u, int w)
{
if (!u)
{
u = ++ idx;
v[u] = w;
}
else if (w <= v[u]) insert(l[u], w);
else insert(r[u], w);
}
2、如何记录每一层的节点数量
（1）y总的做法——dfs ，记录深度
void dfs(int u, int depth)
{
if (!u) return;
cnt[depth] ++ ;
max_depth = max(max_depth, depth);
dfs(l[u], depth + 1);
dfs(r[u], depth + 1);
}
（2） 我的做法——层序遍历
queue<PII> q;
q.push({0, 1});
int cnt[N], max_level = 0;
while(q.size()){
int top = q.front().first;
int level = q.front().second;
q.pop();
cnt[level] ++;
max_level = max(level, max_level);
if(l[top] != -1) {
q.push({l[top], level + 1});
}
if(r[top] != -1) {
q.push({r[top], level + 1});
}
}
自己的代码
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int N = 1e3 + 10;
int tr[N], l[N], r[N], a[N];
int idx = 0;
typedef pair<int, int> PII;
void insert(int u, int k){
if(k <= tr[u]) {
if(l[u] != -1)
insert(l[u], k);
else{
l[u] = ++idx;
tr[idx] = k;
}
}
else{
if(r[u] != -1)
insert(r[u], k);
else{
r[u] = ++idx;
tr[idx] = k;
}
}
}
int main(){
int n, i;
cin>>n;
memset(l, -1, sizeof l);
memset(r, -1, sizeof r);
int root = 0;
for(i = 0; i < n; i ++){
cin>>a[i];
if(!i) tr[root] = a[i];
else insert(root, a[i]);
}
//层序遍历
queue<PII> q;
q.push({0, 1});
int cnt[N], max_level = 0;
while(q.size()){
int top = q.front().first;
int level = q.front().second;
q.pop();
cnt[level] ++;
max_level = max(level, max_level);
if(l[top] != -1) {
q.push({l[top], level + 1});
}
if(r[top] != -1) {
q.push({r[top], level + 1});
}
}
printf("%d + %d = %d", cnt[max_level], cnt[max_level - 1], cnt[max_level] + cnt[max_level - 1]);
}
y总的代码
#include <iostream>
using namespace std;
const int N = 1010;
int n;
int l[N], r[N], v[N], idx;
int cnt[N], max_depth;
void insert(int& u, int w)
{
if (!u)
{
u = ++ idx;
v[u] = w;
}
else if (w <= v[u]) insert(l[u], w);
else insert(r[u], w);
}
void dfs(int u, int depth)
{
if (!u) return;
cnt[depth] ++ ;
max_depth = max(max_depth, depth);
dfs(l[u], depth + 1);
dfs(r[u], depth + 1);
}
int main()
{
cin >> n;
int root = 0;
for (int i = 0; i < n; i ++ )
{
int w;
cin >> w;
insert(root, w);
}
dfs(root, 0);
int n1 = cnt[max_depth], n2 = cnt[max_depth - 1];
printf("%d + %d = %d\n", n1, n2, n1 + n2);
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/283562/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
前序和后序遍历
题目
假设一个二叉树上所有结点的权值都互不相同。
我们可以通过后序遍历和中序遍历来确定唯一二叉树。
也可以通过前序遍历和中序遍历来确定唯一二叉树。
但是，如果只通过前序遍历和后序遍历，则有可能无法确定唯一二叉树。
现在，给定一组前序遍历和后序遍历，请你输出对应二叉树的中序遍历。
如果树不是唯一的，则输出任意一种可能树的中序遍历即可。
输入格式
第一行包含整数 N，表示结点数量。
第二行给出前序遍历序列。
第三行给出后序遍历序列。
一行中的数字都用空格隔开。
输出格式
首先第一行，如果树唯一，则输出 Yes，如果不唯一，则输出 No。
然后在第二行，输出树的中序遍历。
注意，如果树不唯一，则输出任意一种可能的情况均可。
数据范围
1≤N≤30
输入样例1：
7
1 2 3 4 6 7 5
2 6 7 4 5 3 1
输出样例1：
Yes
2 1 6 4 7 3 5
输入样例2：
4
1 2 3 4
2 4 3 1
输出样例2：
No
2 1 3 4
思想
关键：找到不同遍历之间的特点！
// 先序遍历是根左右，后序遍历是左右根，我们没法判断左子树在哪里结束，于是我们通过枚举的方式,去递归遍历
// 枚举左子树在不同位置结束的时候的方案数，如果方案数 > 1,说明不唯一
// 同时在过程中，由于每次遍历左右子树，于是我们可以借此求得中序遍历。
自己的代码
// 先序遍历是根左右，后序遍历是左右根，我们没法判断左子树在哪里结束，于是我们通过枚举的方式,去递归遍历
// 枚举左子树在不同位置结束的时候的方案数，如果方案数 > 1,说明不唯一
// 同时在过程中，由于每次遍历左右子树，于是我们可以借此求得中序遍历。
#include<iostream>
using namespace std;
const int N = 40;
int pre[N], post[N];
int dfs(int l1, int r1, int l2, int r2, string& in){
//l1是pre， l2是post
if(l1 > r1) return 1;//注意这里是return 1
if(pre[l1] != post[r2]) return 0;
int cnt = 0;
for (int i = l1; i <= r1; i ++ ){//按理来说，i应该是从l1 + 1开始的，但是如果改成l1 + 1，就会报错
string lin, rin;
int lcnt = dfs(l1 + 1, i, l2, l2 + i - l1 - 1, lin);
int rcnt = dfs(i + 1, r1, l2 + i - l1 , r2 - 1, rin);
if(lcnt && rcnt){
cnt += lcnt * rcnt;
in = lin + to_string(pre[l1]) + ' ' + rin;
if(cnt > 1) break;
}
}
return cnt;
}
int main(){
int n, i;
cin>>n;
for(i = 0; i < n; i ++) cin>>pre[i];
for(i = 0; i < n; i ++) cin>>post[i];
string in;
int cnt = dfs(0, n - 1, 0, n - 1, in);
if (cnt > 1) puts("No");
else puts("Yes");
in.pop_back();//会多一个空格，所以要pop_back
cout << in << endl;
}
y总的代码
#include <iostream>
using namespace std;
const int N = 40;
int n;
int pre[N], post[N];
int dfs(int l1, int r1, int l2, int r2, string& in)
{
if (l1 > r1) return 1;
if (pre[l1] != post[r2]) return 0;
int cnt = 0;
for (int i = l1; i <= r1; i ++ ) // 枚举左子树包含的节点数量
{
string lin, rin;
int lcnt = dfs(l1 + 1, i, l2, l2 + i - l1 - 1, lin);
int rcnt = dfs(i + 1, r1, l2 + i - l1 - 1 + 1, r2 - 1, rin);
if (lcnt && rcnt)
{
in = lin + to_string(pre[l1]) + ' ' + rin;
cnt += lcnt * rcnt;
if (cnt > 1) break;
}
}
return cnt;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ ) cin >> pre[i];
for (int i = 0; i < n; i ++ ) cin >> post[i];
string in;
int cnt = dfs(0, n - 1, 0, n - 1, in);
if (cnt > 1) puts("No");
else puts("Yes");
in.pop_back();
cout << in << endl;
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/283585/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
Z字形遍历二叉树
题目
假设一个二叉树上各结点的权值互不相同。
我们就可以通过其后序遍历和中序遍历来确定唯一二叉树。
请你输出该二叉树的 Z 字形遍历序列----也就是说，从根结点开始，逐层遍历，第一层从右到左遍历，第二层从左到右遍历，第三层从右到左遍历，以此类推。
例如，下图所示二叉树，其 Z 字形遍历序列应该为：1 11 5 8 17 12 20 15。
输入格式
第一行包含整数 N，表示二叉树结点数量。
第二行包含 N 个整数，表示二叉树的中序遍历序列。
第三行包含 N 个整数，表示二叉树的后序遍历序列。
输出格式
输出二叉树的 Z 字形遍历序列。
数据范围
1≤N≤30
输入样例：
8
12 11 20 17 1 15 8 5
12 20 17 11 15 8 5 1
输出样例：
1 11 5 8 17 12 20 15
思想
1、给定二叉树中序遍历和后序遍历，重建二叉树
int build(int il, int ir, int pl, int pr)
{
int root = post[pr];
int k = pos[root];
if (il < k) l[root] = build(il, k - 1, pl, pl + k - 1 - il);
if (k < ir) r[root] = build(k + 1, ir, pl + k - 1 - il + 1, pr - 1);
return root;
}
2、Z字形层序遍历
只有在偶数层时翻转即可
reverse函数的使用，第二个形参是最后一位的下一个位置
void bfs(int root)
{
int hh = 0, tt = 0;
q[0] = root;
int step = 0;
while (hh <= tt)
{
int head = hh, tail = tt;
while (hh <= tail)
{
int t = q[hh ++ ];
if (l.count(t)) q[ ++ tt] = l[t];
if (r.count(t)) q[ ++ tt] = r[t];
}
if ( ++ step % 2) reverse(q + head, q + tail + 1);
}
}
自己的代码
//y总的
//y总的思路，将奇数层的翻转即可
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
using namespace std;
const int N = 40;
int n;
unordered_map<int, int> l, r, pos;
int in[N], post[N];
int q[N];
int build(int il, int ir, int pl, int pr)
{
int root = post[pr];
int k = pos[root];
if (il < k) l[root] = build(il, k - 1, pl, pl + k - 1 - il);
if (k < ir) r[root] = build(k + 1, ir, pl + k - 1 - il + 1, pr - 1);
return root;
}
//这里记录了如何写出层序遍历每一层的写法，q即为层序遍历结果
void bfs(int root){
int hh = 0, tt = 0;
q[0] = root;
int step = 0;
while(hh <= tt){
int head = hh, tail = tt;
while(hh <= tail){//只遍历到上一层添加到的tt处
int t = q[hh ++];
if (l.count(t)) q[ ++ tt] = l[t];
if (r.count(t)) q[ ++ tt] = r[t];
}
if(++ step % 2 == 1) reverse(q + head, q + tail + 1);
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ )
{
cin >> in[i];
pos[in[i]] = i;
}
for (int i = 0; i < n; i ++ ) cin >> post[i];
int root = build(0, n - 1, 0, n - 1);
bfs(root);
cout << q[0];
for (int i = 1; i < n; i ++ ) cout << ' ' << q[i];
cout << endl;
return 0;
}
//自己的代码
/*#include <iostream>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;
const int N = 1e4 + 10;
int post[N], in[N], r[N], l[N], pos[N];
typedef pair<int, int> PII;
int build(int l1, int r1, int l2, int r2){
if(l1 > r1) return false;
int root = post[r2];
int k = pos[root];
if(l1 < k) l[root] = build(l1, k - 1, l2, l2 + k - 1- l1);
if(k < r1) r[root] = build(k + 1, r1, l2 + k - l1, r2 - 1);
return root;
}
int main(){
int n;
cin>>n;
for (int i = 0; i < n; i ++ )
{
cin >> in[i];
pos[in[i]] = i;
}
for(int i = 0; i < n; i ++) cin>>post[i];
memset(l, -1, sizeof l);
memset(r, -1, sizeof r);
int root = build(0, n - 1, 0, n - 1);
queue<PII> q;
q.push({root, 1});
//cout<<root;
int before_level = 1;
string str;
queue<PII> a;
while(q.size()){
int top = q.front().first;
int level = q.front().second;
if(before_level != level){
if(level % 2 == 1){
//reverse(q);
a = q;
stack<PII> s;
while(a.size()){
s.push(a.front());
a.pop();
}
while(s.size()){
a.push(s.top());
s.pop();
}
}
}
if(level > 2 && level % 2 == 1){
str += to_string(a.front().first) + " ";
a.pop();
}
else str += to_string(top) + " ";
//cout<<top<<endl;
q.pop();
before_level = level;
if(l[top] != -1)
q.push({l[top], level + 1});
if(r[top] != -1)
q.push({r[top], level + 1});
}
str.pop_back();
cout<<str<<endl;
}*/
y总的代码
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
using namespace std;
const int N = 40;
int n;
unordered_map<int, int> l, r, pos;
int in[N], post[N];
int q[N];
int build(int il, int ir, int pl, int pr)
{
int root = post[pr];
int k = pos[root];
if (il < k) l[root] = build(il, k - 1, pl, pl + k - 1 - il);
if (k < ir) r[root] = build(k + 1, ir, pl + k - 1 - il + 1, pr - 1);
return root;
}
void bfs(int root)
{
int hh = 0, tt = 0;
q[0] = root;
int step = 0;
while (hh <= tt)
{
int head = hh, tail = tt;
while (hh <= tail)
{
int t = q[hh ++ ];
if (l.count(t)) q[ ++ tt] = l[t];
if (r.count(t)) q[ ++ tt] = r[t];
}
if ( ++ step % 2) reverse(q + head, q + tail + 1);
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ )
{
cin >> in[i];
pos[in[i]] = i;
}
for (int i = 0; i < n; i ++ ) cin >> post[i];
int root = build(0, n - 1, 0, n - 1);
bfs(root);
cout << q[0];
for (int i = 1; i < n; i ++ ) cout << ' ' << q[i];
cout << endl;
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/283592/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
后序遍历
题目
假设二叉树上各结点的权值互不相同且都为正整数。
给定二叉树的前序遍历和中序遍历，请你输出二叉树的后序遍历的第一个数字。
输入格式
第一行包含整数 N，表示二叉树结点总数。
第二行给出二叉树的前序遍历序列。
第三行给出二叉树的中序遍历序列。
输出格式
输出二叉树的后序遍历的第一个数字。
数据范围
1≤N≤50000
输入样例：
7
1 2 3 4 5 6 7
2 3 1 5 4 7 6
输出样例：
3
思想
自己的代码
//这题要用哈希表来存，不能用遍历来找root的下标，会超时
//其他题，也可能用哈希表存l，和r， 因为不知道节点的值多大，有可能很大
#include<iostream>
#include <unordered_map>
using namespace std;
unordered_map<int,int> pos;
int post = 0;
const int N = 1e5 + 10;
int pre[N], in[N];
void build(int pl, int pr, int il, int ir){
int root = pre[pl];
int k = pos[root];
if(il < k) build(pl + 1, pl + + 1 + k - 1 - il, il, k - 1);
if(k < ir) build(pl + 1 + k - 1 - il + 1, pr, k + 1, ir);
if(!post) post = root;//第一个return的就是它
}
int main(){
int n;
cin>>n;
for (int i = 0; i < n; i ++ ) cin >> pre[i];
for (int i = 0; i < n; i ++ )
{
cin >> in[i];
pos[in[i]] = i;
}
build(0, n - 1, 0, n - 1);
cout<<post<<endl;
}
y总的代码
#include <iostream>
#include <unordered_map>
using namespace std;
const int N = 50010;
int n;
int pre[N], in[N];
unordered_map<int, int> pos;
int post;
void build(int il, int ir, int pl, int pr)
{
int root = pre[pl];
int k = pos[root];
if (il < k) build(il, k - 1, pl + 1, pl + 1 + k - 1 - il);
if (k < ir) build(k + 1, ir, pl + 1 + k - 1 - il + 1, pr);
if (!post) post = root;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ ) cin >> pre[i];
for (int i = 0; i < n; i ++ )
{
cin >> in[i];
pos[in[i]] = i;
}
build(0, n - 1, 0, n - 1);
cout << post << endl;
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/283601/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
AVL树的根
题目
AVL树是一种自平衡二叉搜索树。
在AVL树中，任何节点的两个子树的高度最多相差 1 个。
如果某个时间，某节点的两个子树之间的高度差超过 1，则将通过树旋转进行重新平衡以恢复此属性。
图 1−4 说明了旋转规则。
31.jpg 32.jpg
33.jpg 34.jpg
现在，给定插入序列，请你求出 AVL 树的根是多少。
输入格式
第一行包含整数 N，表示总插入值数量。
第二行包含 N 个不同的整数，表示每个插入值。
输出格式
输出得到的 AVL 树的根是多少。
数据范围
1≤N≤20
输入样例1：
5
88 70 61 96 120
输出样例1：
70
输入样例2：
7
88 70 61 96 120 90 65
输出样例2：
88
思想
待补充！！！！
自己的代码
#include<iostream>
using namespace std;
const int N = 100;
int l[N], r[N], h[N], v[N];
int idx = 0;
void update(int u){
h[u] = max(h[l[u]], h[r[u]]) + 1;
}
void R(int &u){
int p = l[u];
l[u] = r[p];
r[p] = u;
update(u),update(p);//更新高度
u = p;//要用引用更新根
}
void L(int &u){
int p = r[u];
r[u] = l[p];
l[p] = u;
update(u),update(p);
u = p;
}
int get_balance(int u){
return h[l[u]] - h[r[u]];
}
void insert(int &u, int w){
if(!u){//第一种情况，一开始u==0， 第二种l[u]或r[u]==0,插入到对应位置
u = ++ idx;//注意0位置不存任何东西，0位置时用来表示空的
v[u] = w;
}
else if(w < v[u]){
insert(l[u], w);
if(get_balance(u) == 2){
if(get_balance(l[u]) == 1) R(u);
else L(l[u]), R(u);
}
}
else{
insert(r[u], w);
if (get_balance(u) == -2)
{
if(get_balance(r[u]) == -1) L(u);//注意这里是-1
else R(r[u]), L(u);
}
}
update(u);//每次插入都要更新h
}
int main(){
int n;
cin>>n;
int u = 0, i, w;
for(i = 0; i < n; i ++){
cin>>w;
insert(u, w);
}
cout<<v[u]<<endl;
}
y总的代码
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 30;
int l[N], r[N], v[N], h[N], idx;
void update(int u)
{
h[u] = max(h[l[u]], h[r[u]]) + 1;
}
void R(int& u)
{
int p = l[u];
l[u] = r[p], r[p] = u;
update(u), update(p);
u = p;
}
void L(int& u)
{
int p = r[u];
r[u] = l[p], l[p] = u;
update(u), update(p);
u = p;
}
int get_balance(int u)
{
return h[l[u]] - h[r[u]];
}
void insert(int& u, int w)
{
if (!u) u = ++ idx, v[u] = w;
else if (w < v[u])
{
insert(l[u], w);
if (get_balance(u) == 2)
{
if (get_balance(l[u]) == 1) R(u);
else L(l[u]), R(u);
}
}
else
{
insert(r[u], w);
if (get_balance(u) == -2)
{
if (get_balance(r[u]) == -1) L(u);
else R(r[u]), L(u);
}
}
update(u);
}
int main()
{
int n, root = 0;
cin >> n;
while (n -- )
{
int w;
cin >> w;
insert(root, w);
}
cout << v[root] << endl;
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/283632/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
判断完全AVL树
题目
AVL树是一种自平衡二叉搜索树。
在AVL树中，任何节点的两个子树的高度最多相差 1 个。
如果某个时间，某节点的两个子树之间的高度差超过 1，则将通过树旋转进行重新平衡以恢复此属性。
图 1−4 说明了旋转规则。
1.jpg 2.jpg
3.jpg 4.jpg
现在，给定插入序列，请你输出得到的AVL树的层序遍历，并判断它是否是完全二叉树。
输入格式
第一行包含整数 N，表示插入序列中元素个数。
第二行包含 N 个不同的整数表示插入序列。
输出格式
第一行输出得到的AVL树的层序遍历序列。
第二行，如果该AVL树是完全二叉树，则输出 YES，否则输出 NO。
数据范围
1≤N≤20
输入样例1：
5
88 70 61 63 65
输出样例1：
70 63 88 61 65
YES
输入样例2：
8
88 70 61 96 120 90 65 68
输出样例2：
88 65 96 61 70 90 120 68
NO
难度：中等
时/空限制：0.4s / 64MB
总通过数：374
总尝试数：634
来源：PAT甲级真题1123
算法标签
代码
#include <iostream>
using namespace std;
const int N = 30;
int n;
int l[N], r[N], v[N], h[N], idx;
int q[N], pos[N];
void update(int u)
{
h[u] = max(h[l[u]], h[r[u]]) + 1;
}
void R(int& u)
{
int p = l[u];
l[u] = r[p], r[p] = u;
update(u), update(p);
u = p;
}
void L(int& u)
{
int p = r[u];
r[u] = l[p], l[p] = u;
update(u), update(p);
u = p;
}
int get_balance(int u)
{
return h[l[u]] - h[r[u]];
}
void insert(int& u, int w)
{
if (!u) u = ++ idx, v[u] = w;
else if (w < v[u])
{
insert(l[u], w);
if (get_balance(u) == 2)
{
if (get_balance(l[u]) == 1) R(u);
else L(l[u]), R(u);
}
}
else
{
insert(r[u], w);
if (get_balance(u) == -2)
{
if (get_balance(r[u]) == -1) L(u);
else R(r[u]), L(u);
}
}
update(u);
}
bool bfs(int root)
{
int hh = 0, tt = 0;
q[0] = root;
pos[root] = 1;
bool res = true;
while (hh <= tt)
{
int t = q[hh ++ ];
if (pos[t] > n) res = false;
if (l[t]) q[ ++ tt] = l[t], pos[l[t]] = pos[t] * 2;
if (r[t]) q[ ++ tt] = r[t], pos[r[t]] = pos[t] * 2 + 1;
}
return res;
}
int main()
{
int root = 0;
cin >> n;
for (int i = 0; i < n; i ++ )
{
int w;
cin >> w;
insert(root, w);
}
bool res = bfs(root);
cout << v[q[0]];
for (int i = 1; i < n; i ++ ) cout << ' ' << v[q[i]];
cout << endl;
if (res) puts("YES");
else puts("NO");
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/283649/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
判断红黑树
待补充！！！
题目
思想
代码
等重路径
题目
给定一个非空的树，树根为 R。
树中每个节点 Ti 的权重为 Wi。
从 R 到 L 的路径权重定义为从根节点 R 到任何叶节点 L 的路径中包含的所有节点的权重之和。
现在给定一个加权树以及一个给定权重数字，请你找出树中所有的权重等于该数字的路径（必须从根节点到叶节点）。
例如，我们考虑下图的树，对于每个节点，上方的数字是节点 ID，它是两位数字，而下方的数字是该节点的权重。
假设给定数为 24，则存在 4 个具有相同给定权重的不同路径：{10 5 2 7}，{10 4 10}，{10 3 3 6 2}，{10 3 3 6 2}， 已经在图中用红色标出。
输入格式
第一行包含三个整数 N,M,S，分别表示树的总节点数量，非叶子节点数量，给定权重数字。
第二行包含 N 个整数 Wi，表示每个节点的权重。
接下来 M 行，每行的格式为：
ID K ID[1] ID[2] … ID[K]
ID 是一个两位数字，表示一个非叶子结点编号，K 是一个整数，表示它的子结点数，接下来的 K 个 ID[i] 也是两位数字，表示一个子结点的编号。
出于方便考虑，根节点固定为 00，且树中所有节点的编号为 00∼N−1。
输出格式
以单调递减的顺序输出所有权重为S的路径。
每个路径占一行，从根节点到叶节点按顺序输出每个节点的权重。
注意：我们称 A 序列 {A1,A2,…,An} 大于 B 序列 {B1,B2,…,Bm}，当且仅当存在一个整数 k，1≤k<min(n,m)，对于所有 1≤i≤k，Ai=Bi 成立，并且 Ak+1>Bk+1。
数据范围
1≤N≤100,
0≤M<N,
0<S<230,
0<Wi<1000
输入样例：
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
难度：中等
时/空限制：0.4s / 64MB
总通过数：504
总尝试数：801
来源：PAT甲级真题1053
算法标签
思想
1、dfs去求
void dfs(int u, int s, vector<int> &path)
{
bool is_leaf = true;
for (int i = 0; i < n; i ++ )
if (g[u][i])
{
is_leaf = false;
break;
}
if (is_leaf)
{
if (s == S) ans.push_back(path);
}
else
{
for (int i = 0; i < n; i ++ )
if (g[u][i])
{
path.push_back(w[i]);
dfs(i, s + w[i], path);
path.pop_back();
}
}
}
2、 从大到小排序，价格后面的greater
vector<vector<int>> ans;
sort(ans.begin(), ans.end(), greater<vector<int>>());
自己的代码
//用vector可以实现如上的比较
//用vector<vector<int>> 来存路径
//判断叶子节点——bool数组，我感觉很多方法都可以
//使用dfs可以搜索从根节点到每一个叶子节点的路径
#include<iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 110;
int w[N];
bool g[N][N];
vector<vector<int>> ans;
int n, m, S;
void dfs(int u, int s, vector<int> &path){
bool is_leaf = true;
for(int i = 0; i < n; i ++){
if(g[u][i]){
is_leaf = false;
break;
}
}
if(is_leaf){
if(s == S)
ans.push_back(path);
return;
}
else{
for(int i = 0; i < n; i ++){
if(g[u][i]){
path.push_back(w[i]);
dfs(i,s + w[i],path);
path.pop_back();
}
}
}
return;
}
int main(){
cin>>n>>m>>S;
for(int i = 0; i < n; i ++) cin>>w[i];
for(int i = 0; i < m; i ++){
int id, k;
cin>>id>>k;
for(int j = 0; j < k; j ++){
int child;
cin>>child;
g[id][child] = true;
}
}
vector<int> path;
path.push_back(w[0]);
dfs(0, w[0], path);
sort(ans.begin(), ans.end(), greater<vector<int>>());//这个greater什么意思？？？？
for(auto an : ans){
cout<<an[0];
for(int i = 1; i < an.size(); i ++){
cout<<" "<<an[i];
}
cout<<endl;
}
}
y总的代码
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 110;
int n, m, S;
int w[N];
bool g[N][N];
vector<vector<int>> ans;
void dfs(int u, int s, vector<int> &path)
{
bool is_leaf = true;
for (int i = 0; i < n; i ++ )
if (g[u][i])
{
is_leaf = false;
break;
}
if (is_leaf)
{
if (s == S) ans.push_back(path);
}
else
{
for (int i = 0; i < n; i ++ )
if (g[u][i])
{
path.push_back(w[i]);
dfs(i, s + w[i], path);
path.pop_back();
}
}
}
int main()
{
cin >> n >> m >> S;
for (int i = 0; i < n; i ++ ) cin >> w[i];
while (m -- )
{
int id, k;
cin >> id >> k;
while (k -- )
{
int son;
cin >> son;
g[id][son] = true;
}
}
vector<int> path({w[0]});
dfs(0, w[0], path);
sort(ans.begin(), ans.end(), greater<vector<int>>());
for (auto p : ans)
{
cout << p[0];
for (int i = 1; i < p.size(); i ++ ) cout << ' ' << p[i];
cout << endl;
}
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/294234/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
标签：遍历,PAT,int,cin,++,甲级,include,root 来源： https://blog.csdn.net/Yttttttttttttttt/article/details/120189366