PAT甲级题分类汇编——树

时间 2019-11-17

标签 pat 甲级分类汇编繁體版

原文原文链接

AVL树好难！（其实还好啦~）node

我原本想着今天应该作不完树了，没想到电脑里有一份讲义，PPT和源代码都有，就一遍复习一遍抄码了一遍，更没想到的是编译一遍经过，再没想到的是运行也正常，最没想到的是一遍AC。ios

其实不少题都有数，std::set 之类用的是红黑树，听说很复杂，比AVL树还要复杂的那种。可是，用到这些设施的题，都不在这一分类下，这一分类下的题，由于题目要求本身建树，也就不用标准库设施了。算法

大多数题中，树在内存中都是连续存放的。不是像彻底二叉树那样的连续，是物理上连续而逻辑上用数组下表代替指针。设计模式

题号	标题	分数	大意
1053	Path of Equal Weight	30	寻找树中必定权重的路径
1064	Complete Binary Search Tree	30	彻底二叉搜索树
1066	Root of AVL Tree	25	AVL树的根
1086	Tree Traversals Again	25	中序遍历逆推
1094	The Largest Generation	25	树中元素最多的层
1099	Build A Binary Search Tree	30	创建二叉搜索树

这一系列的题仍是清一色地某姥姥出的。数组

学数据结构的时候作过1064和1086，遇到过1066，但跳过了。数据结构

此次除了1086和1094都写，毕竟不能放着30分题无论。30分题一遍AC，别提有多爽了。less

1053：函数

要求按非升序输出权重，使其和为给定值。ui

一开始没看清题，觉得是根节点到任意节点，就写了个有点像Dijkstra的东西，后来跑样例结果不对，才发现是根节点到叶节点，反而更简单了。

 1 #include <iostream>
 2 #include <vector>
 3 #include <queue>
 4 #include <algorithm>
 5 
 6 struct Node
 7 {
 8     int index;
 9     int weight;
10     std::vector<int> children;
11     std::vector<int> weights;
12     int total;
13 };
14 
15 int main()
16 {
17     int num_node, num_nonleaf, target;
18     std::cin >> num_node >> num_nonleaf >> target;
19     std::vector<Node> nodes(num_node);
20     for (auto& n : nodes)
21         std::cin >> n.weight;
22     for (int i = 0; i != num_node; ++i)
23         nodes[i].index = i;
24     for (int i = 0; i != num_nonleaf; ++i)
25     {
26         int index;
27         std::cin >> index;
28         auto& node = nodes[index];
29         int count;
30         std::cin >> count;
31         node.children.resize(count);
32         for (auto& i : node.children)
33             std::cin >> i;
34     }
35     if (nodes.front().weight == target)
36     {
37         std::cout << target;
38         return 0;
39     }
40     nodes.front().total = nodes.front().weight;
41     nodes.front().weights.push_back(nodes.front().weight);
42     std::queue<int> queue;
43     std::vector<int> selected;
44     queue.push(0);
45     while (!queue.empty())
46     {
47         auto& node = nodes[queue.front()];
48         queue.pop();
49         for (auto& i : node.children)
50         {
51             auto& n = nodes[i];
52             n.weights = node.weights;
53             n.weights.push_back(n.weight);
54             n.total = node.total + n.weight;
55             if (n.total == target && n.children.empty())
56                 selected.push_back(n.index);
57             else if (n.total < target)
58                 queue.push(n.index);
59         }
60     }
61     std::sort(selected.begin(), selected.end(), [&](int i, int j) {
62         return nodes[i].weights > nodes[j].weights;
63     });
64     for (const auto& i : selected)
65     {
66         auto& node = nodes[i];
67         auto end = node.weights.end() - 1;
68         for (auto iter = node.weights.begin(); iter != end; ++iter)
69             std::cout << *iter << ' ';
70         std::cout << *end;
71         std::cout << std::endl;
72     }
73 }

一个小坑是根节点权重就是要求的值，而个人算法老是处理当前节点的子节点，而根节点没有前驱节点，因此要加个特殊状况讨论。一个case而已，想了两分钟就发现了。

1064：

做为标准库的狂热爱好者，我写的数据结构最好也要有迭代器，这道题是绝佳的平台。层序遍历迭代器就用 std::vector 的迭代器就行，中序遍历迭代器得本身写。

 1 #include <iostream>
 2 #include <vector>
 3 #include <algorithm>
 4 #include <queue>
 5 
 6 class InOrderIterator
 7 {
 8 public:
 9     InOrderIterator(std::vector<int>& _rVector)
10         : data_(_rVector)
11     {
12         auto s = data_.size() - 1;
13         int count = 0;
14         while (s >>= 1)
15             ++count;
16         index_ = 1 << count;
17     }
18     int& operator*()
19     {
20         return data_[index_];
21     }
22     InOrderIterator& operator++()
23     {
24         if (index_ * 2 + 1 < data_.size())
25         {
26             index_ = index_ * 2 + 1;
27             while ((index_ *= 2) < data_.size())
28                 ;
29             index_ /= 2;
30         }
31         else
32         {
33             int count = 1, i = index_;
34             while (i % 2)
35                 i >>= 1, ++count;
36             index_ >>= count;
37         }
38         return *this;
39     }
40 private:
41     std::vector<int>& data_;
42     int index_;
43 };
44 
45 int main(int argc, char const *argv[])
46 {
47     int n;
48     std::cin >> n;
49     std::vector<int> data(n);
50     for (int i = 0; i != n; ++i)
51         std::cin >> data[i];
52 
53     std::sort(data.begin(), data.end());
54     std::vector<int> tree(n + 1);
55     InOrderIterator iter(tree);
56     for (auto i : data)
57         *iter = i, ++iter;
58 
59     auto size = tree.size() - 1;
60     for (auto i = 1; i != size; ++i)
61         std::cout << tree[i] << ' ';
62     std::cout << tree[size];
63 
64     return 0;
65 }

这个迭代算法我想了很久，当时以为很优雅。如今本身都看不懂，好像是什么位操做吧。

然而，一样是迭代，1099题中的算法就比这个简单得多，后面会讲。

1066：

这道题我一直不敢作。实际上，左旋右旋什么的在个人脑海中一直都只是名词——我从未实现过一个AVL树，直到今天。在PPT与代码的帮助下，我顺利地写了一个AvlTree类模板，实现了一部分接口。

AVL树的4种旋转，学的时候听得懂，写的时候以为烦，真的写完了也不过如此，其实没什么复杂的。

  1 #include <iostream>
  2 #include <utility>
  3 #include <functional>
  4 
  5 template <typename T, typename Comp = std::less<T>>
  6 class AvlTree
  7 {
  8 public:
  9     AvlTree();
 10     void insert(T _key);
 11     void root(T& _target);
 12 private:
 13     struct Node
 14     {
 15         Node(T&& _key);
 16         T key_;
 17         Node* left_ = nullptr;
 18         Node* right_ = nullptr;
 19         int height_;
 20         static int height(Node* _node);
 21     };
 22     Node* node_ = nullptr;
 23     static void insert(Node*& _node, T&& _key);
 24     static void single_left(Node*& _node);
 25     static void single_right(Node*& _node);
 26     static void double_left_right(Node*& _node);
 27     static void double_right_left(Node*& _node);
 28 };
 29 
 30 template<typename T, typename Comp>
 31 AvlTree<T, Comp>::AvlTree() = default;
 32 template<typename T, typename Comp>
 33 void AvlTree<T, Comp>::insert(T _key)
 34 {
 35     insert(node_, std::move(_key));
 36 }
 37 
 38 template<typename T, typename Comp>
 39 void AvlTree<T, Comp>::root(T& _target)
 40 {
 41     if (node_)
 42         _target = node_->key_;
 43 }
 44 
 45 template<typename T, typename Comp>
 46 void AvlTree<T, Comp>::insert(Node*& _node, T&& _key)
 47 {
 48     if (!_node)
 49         _node = new Node(std::move(_key));
 50     else if (Comp()(_key, _node->key_))
 51     {
 52         insert(_node->left_, std::move(_key));
 53         if (Node::height(_node->left_) - Node::height(_node->right_) == 2)
 54             if (Comp()(_key, _node->left_->key_))
 55                 single_left(_node);
 56             else
 57                 double_left_right(_node);
 58     }
 59     else if (Comp()(_node->key_, _key))
 60     {
 61         insert(_node->right_, std::move(_key));
 62         if (Node::height(_node->right_) - Node::height(_node->left_) == 2)
 63             if (Comp()(_node->right_->key_, _key))
 64                 single_right(_node);
 65             else
 66                 double_right_left(_node);
 67     }
 68     Node::height(_node);
 69 }
 70 
 71 template<typename T, typename Comp>
 72 void AvlTree<T, Comp>::single_left(Node*& _node)
 73 {
 74     auto temp = _node->left_;
 75     _node->left_ = temp->right_;
 76     temp->right_ = _node;
 77     Node::height(_node);
 78     Node::height(temp);
 79     _node = temp;
 80 }
 81 
 82 template<typename T, typename Comp>
 83 void AvlTree<T, Comp>::single_right(Node*& _node)
 84 {
 85     auto temp = _node->right_;
 86     _node->right_ = temp->left_;
 87     temp->left_ = _node;
 88     Node::height(_node);
 89     Node::height(temp);
 90     _node = temp;
 91 }
 92 
 93 template<typename T, typename Comp>
 94 void AvlTree<T, Comp>::double_left_right(Node*& _node)
 95 {
 96     single_right(_node->left_);
 97     single_left(_node);
 98 }
 99 
100 template<typename T, typename Comp>
101 void AvlTree<T, Comp>::double_right_left(Node*& _node)
102 {
103     single_left(_node->right_);
104     single_right(_node);
105 }
106 
107 template<typename T, typename Comp>
108 AvlTree<T, Comp>::Node::Node(T&& _key)
109     : key_(std::move(_key))
110 {
111     ;
112 }
113 
114 template<typename T, typename Comp>
115 int AvlTree<T, Comp>::Node::height(Node* _node)
116 {
117     if (!_node)
118         return 0;
119     auto left = _node->left_ ? height(_node->left_) : 0;
120     auto right = _node->right_ ? height(_node->right_) : 0;
121     _node->height_ = (left > right ? left : right) + 1;
122     return _node->height_;
123 }
124 
125 int main()
126 {
127     AvlTree<int> tree;
128     int num;
129     std::cin >> num;
130     for (int i = 0; i != num; ++i)
131     {
132         int t;
133         std::cin >> t;
134         tree.insert(t);
135     }
136     int root;
137     tree.root(root);
138     std::cout << root;
139 }

1099：

给定一个二叉搜索树结构和一系列数据，让你往里填，而后层序输出。

只要能够递归，前中后序遍历都不是问题。这道题讲明了N小于等于100，就算100级递归也OK，那就固然没有必要避免递归。

等等，我不是标准库的狂热爱好者吗？都用起递归了，还怎么写迭代器啊？用递归就必定不是迭代器吗？否则。

迭代是什么？数学上，迭表明现为a=f(a)；程序设计中，迭代能够是 i = i + 1; ，这是很数学的写法。C/C++提供了前缀++运算符以代替这一语句，《设计模式》中的迭代器用 Next() 方法来移动到下一个位置。长此以往，迭代器的数学意义上的“迭代”已经不明显了，以致于迭代器在程序设计中彷佛就是指那些能遍历容器的对象。由此，《设计模式》提出了内部迭代器与外部迭代器的概念。

内部迭代器不对外开放，由类自己控制移动，接受谓词参数。优势是实现比较方便，缺点是在那个C++98都没有的年代，C++根本不支持这个，除非紧耦合——你在《设计模式》里紧耦合？

外部迭代器是交给客户使用的，有客户控制。优势是可由客户来控制，能够同时存在多个迭代器等，缺点是实现可能很复杂，好比前面那道题的中序迭代器。

分析完这些概念后，我想在这道题中，最适合的应该是内部迭代器了吧。

 1 #include <iostream>
 2 #include <vector>
 3 #include <queue>
 4 #include <algorithm>
 5 
 6 struct Node
 7 {
 8     int key;
 9     int left;
10     int right;
11     int parent;
12 };
13 
14 template <typename F>
15 void traverse(std::vector<Node>& nodes, int index, F functor)
16 {
17     auto& n = nodes[index];
18     if (n.left != -1)
19         traverse(nodes, n.left, functor);
20     functor(n.key);
21     if (n.right != -1)
22         traverse(nodes, n.right, functor);
23 }
24 
25 int main()
26 {
27     int num;
28     std::cin >> num;
29     std::vector<Node> nodes(num);
30     for (int i = 0; i != num; ++i)
31     {
32         auto& n = nodes[i];
33         std::cin >> n.left >> n.right;
34         if (n.left != -1)
35             nodes[n.left].parent = i;
36         if (n.right != -1)
37             nodes[n.right].parent = i;
38     }
39     std::vector<int> keys(num);
40     for (auto& i : keys)
41         std::cin >> i;
42     std::sort(keys.begin(), keys.end());
43     auto iter = keys.begin();
44     traverse(nodes, 0, [&](int& key) { key = *iter++; });
45     std::queue<int> queue;
46     queue.push(0);
47     int count = 0;
48     while (!queue.empty())
49     {
50         if (count++)
51             std::cout << ' ';
52         auto i = queue.front();
53         queue.pop();
54         auto& n = nodes[i];
55         std::cout << n.key;
56         if (n.left != -1)
57             queue.push(n.left);
58         if (n.right != -1)
59             queue.push(n.right);
60     }
61 }

我无法准确指明到底哪一个东西是所谓内部迭代器。迭代器用于遍历，我只能说，函数模板 traverse 提供一个遍历的接口。和递归版本的树的遍历同样，它也会调用自身。

相比于以前复杂到看不懂的中序迭代器逻辑，这里的迭代器的功能与实现都简洁明了。既用上了递归，使实现简化，又下降了耦合，真是一箭双鵰。