PAT甲级题分类汇编——理论
Posted jerry-fuyi
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了PAT甲级题分类汇编——理论相关的知识,希望对你有一定的参考价值。
理论这一类,是让我觉得特别尴尬的题,纯粹是为了考数据结构而考数据结构。看那Author一栏清一色的某老师,就知道教数据结构的老师的思路就是和别人不一样。
题号 | 标题 | 分数 | 大意 | Author |
1051 | Pop Sequence | 25 | 判断一个序列是否是pop序列 | CHEN, Yue |
1052 | Linked List Sorting | 25 | 链表排序 | CHEN, Yue |
1057 | Stack | 30 | 一个有中位数功能的stack | CHEN, Yue |
1074 | Reversing Linked List | 25 | 分段逆转链表 | CHEN, Yue |
1089 | Insert or Merge | 25 | 判断插入排序或归并排序 | CHEN, Yue |
1097 | Deduplication on a Linked List | 25 | 链表去重 | CHEN, Yue |
1098 | Insertion or Heap Sort | 25 | 判断插入排序或堆排序 | CHEN, Yue |
好几道题在上MOOC的时候就在数据结构题集里面做过,有1051、1074和1089。还有1098,是之前做merge那道的时候想一并做的,但后来因为merge花了太多时间就跳过了。
这次讲1074、1098、1051和1057 4道题。没错,不按题号顺序。
1074:
这可能是我做的第一道PAT题,也可能是第一道卡住的题。其实,所有用5位整数来模拟链表的题,好像都必须创建100000大小的数组,直接寻址才能跑进时间限制, std::map 是不行的。不过呢,如果我一开始是用C做的,肯定就直接建数组了,也就没有后面的问题了。
这道题的讲解在数据结构课程里有。
因为是早期作品,所以代码长得比较尴尬,懒得改了,我想睡觉。
1 #include <iostream> 2 #include <vector> 3 #include <utility> 4 #include <algorithm> 5 #include <type_traits> 6 #include <stack> 7 #include <iomanip> 8 9 struct Node 10 11 int address; 12 int data; 13 int next; 14 ; 15 16 int main(int argc, char const *argv[]) 17 18 int first, n, k; 19 std::cin >> first >> n >> k; 20 std::vector<Node> data(n); 21 for (int i = 0; i != n; ++i) 22 std::cin >> data[i].address >> data[i].data >> data[i].next; 23 24 decltype(data) list; 25 int address = first; 26 for (int i = 0; i != n; ++i) 27 28 auto pos = std::find_if(std::begin(data), std::end(data), [address](const Node& node) 29 return node.address == address; 30 ); 31 list.emplace_back(*pos); 32 address = pos->next; 33 if (address == -1) 34 break; 35 36 n = list.size(); 37 38 auto begin = list.begin(); 39 auto end = begin + (list.end() - begin) / k * k; 40 for (; begin != end; begin += k) 41 42 std::stack<Node> stack; 43 for (auto iter = begin; iter != begin + k; ++iter) 44 stack.push(*iter); 45 for (auto iter = begin; iter != begin + k; ++iter) 46 47 *iter = stack.top(); 48 stack.pop(); 49 50 51 for (int i = 0; i != n - 1; ++i) 52 list[i].next = list[i + 1].address; 53 list[n - 1].next = -1; 54 55 std::cout << std::setfill(‘0‘); 56 for (auto& node : list) 57 58 std::cout << std::setw(5) << node.address << ‘ ‘; 59 std::cout << std::setw(0) << node.data << ‘ ‘; 60 if (node.next == -1) 61 62 std::cout << "-1"; 63 break; 64 65 std::cout << std::setw(5) << node.next << std::endl; 66 67 68 return 0; 69
1098:
它的兄弟题目1089在数据结构课程中讲过,包括这道题中也用到的判断插入排序的方法。
1 #include <iostream> 2 #include <vector> 3 #include <algorithm> 4 5 int main() 6 7 int size; 8 std::cin >> size; 9 std::vector<int> original(size); 10 std::vector<int> partial(size); 11 for (auto& i : original) 12 std::cin >> i; 13 for (auto& i : partial) 14 std::cin >> i; 15 16 int cur = 1; 17 for (; cur != size && partial[cur] >= partial[cur - 1]; ++cur) 18 ; 19 bool insertion = true; 20 for (auto i = cur; i != size; ++i) 21 if (partial[i] != original[i]) 22 23 insertion = false; 24 break; 25 26 27 if (insertion) 28 29 std::cout << "Insertion Sort" << std::endl; 30 int insert = partial[cur]; 31 for (--cur; cur >= 0; --cur) 32 if (partial[cur] > insert) 33 partial[cur + 1] = partial[cur]; 34 else 35 break; 36 partial[cur + 1] = insert; 37 38 else 39 40 std::cout << "Heap Sort" << std::endl; 41 int cur = size - 1; 42 auto top = partial[0]; 43 for (; cur >= 0; --cur) 44 if (partial[cur] <= top) 45 break; 46 if (cur >= 0) 47 48 std::pop_heap(partial.begin(), partial.begin() + cur + 1); 49 partial[cur] = top; 50 51 52 auto end = partial.end() - 1; 53 for (auto iter = partial.begin(); iter != end; ++iter) 54 std::cout << *iter << ‘ ‘; 55 std::cout << *end; 56
其实这道还要稍微简单一点,因为那道题要自己写merge,这道题的heap可以用标准库。<algorithm> 提供了 std::pop_heap 等函数用于堆操作。至于查看堆顶元素,把起始迭代器解引用就好,标准库没有给。
BTW,建堆的操作是O(N)的,证明起来挺组合数学的。
还有呢,我感觉这两道题贼尴尬。
1051:
判断一个序列是不是一个stack中pop出来的序列。
1 #include <iostream> 2 #include <vector> 3 #include <stack> 4 5 class Stack : public std::stack<int> 6 7 using super = std::stack<int>; 8 public: 9 explicit Stack(int _cap) 10 : capacity_(_cap) 11 12 ; 13 14 void push(const int& _data) 15 16 if (size() == capacity_) 17 throw 0; 18 super::push(_data); 19 20 private: 21 int capacity_; 22 ; 23 24 void check(int _cap, const std::vector<int>& _data) 25 26 Stack stack(_cap); 27 int pushed = 0; 28 for (auto i : _data) 29 30 if (stack.empty()) 31 32 stack.push(++pushed); 33 34 if (stack.top() < i) 35 36 for (int j = pushed + 1; j <= i; ++j) 37 stack.push(j); 38 pushed = i; 39 40 if (stack.top() == i) 41 42 stack.pop(); 43 continue; 44 45 if (stack.top() > i) 46 throw 0; 47 48 49 50 int main() 51 52 int m, n, k; 53 std::cin >> m >> n >> k; 54 std::vector<int> data(n); 55 for (int i = 0; i != k; ++i) 56 try 57 58 for (int j = 0; j != n; ++j) 59 std::cin >> data[j]; 60 check(m, data); 61 std::cout << "YES" << std::endl; 62 63 catch(...) 64 65 std::cout << "NO" << std::endl; 66 67 68 return 0; 69
题目不难,这里把代码贴出来,是想作个错误示范。算法本身是正确的,能AC,但是设计是不好的:标准库中的容器类不是用来作基类的,因为其析构函数非虚,我写的 Stack 类直接继承 std::stack<int> 是不好的,尽管在这个类设计中,子类的subclass不需要析构,而且整个程序没有作什么派生类到基类的指针转换。我的本意是想实现adapter,为了偷懒就直接公有继承,理应在 Stack 类中包装一个 std::stack<int> 实例。在工程中,公有继承标准库容器就是错误的。
1057:
这次不按题号讲,就是因为这道题要压轴。
初看,不就一个stack和中位数吗,两个我都会写,放到一起我也会写。然后我就写了第一个版本,做了一个 std::stack<int> 的adapter,提供了push、pop、median操作,其中median是把stack拷贝、排序、寻址中位数。感觉很好,样例也过了,想着一遍AC。
1 #include <iostream> 2 #include <string> 3 #include <vector> 4 #include <algorithm> 5 6 class Stack 7 8 public: 9 Stack() = default; 10 void push(int i) 11 12 stack.push_back(i); 13 14 void pop() 15 16 if (stack.empty()) 17 std::cout << "Invalid"; 18 else 19 20 std::cout << stack.back(); 21 stack.pop_back(); 22 23 std::cout << std::endl; 24 25 void median() 26 27 if (stack.empty()) 28 std::cout << "Invalid"; 29 else 30 31 auto temp = stack; 32 std::sort(temp.begin(), temp.end()); 33 int m = 0; 34 if (temp.size() % 2) 35 m = temp[(temp.size() - 1) / 2]; 36 else 37 m = temp[temp.size() / 2 - 1]; 38 std::cout << m; 39 40 std::cout << std::endl; 41 42 private: 43 std::vector<int> stack; 44 ; 45 46 int main() 47 48 int count; 49 std::cin >> count; 50 Stack stack; 51 for (int i = 0; i != count; ++i) 52 53 std::string instr; 54 std::cin >> instr; 55 if (instr == "Push") 56 57 int i; 58 std::cin >> i; 59 stack.push(i); 60 61 else if (instr == "Pop") 62 63 stack.pop(); 64 65 else 66 67 stack.median(); 68 69 70
然而并没有。5个case,3个超时。
是 std::cin 读取字符串太慢了吗?换成C的输入输出,还有2个case超时。
然后我想到输入数据有个比较小的范围是有用的,就建了个数组,写了个乱七八糟的访问控制来防止每次遍历都把每个元素访问一遍。没用,超时。
我意识到线性结构不能解决这个问题,不然也对不起这30分了。于是我就想到用 std::map 来存储。先放代码:
1 #include <iostream> 2 #include <string> 3 #include <stack> 4 #include <map> 5 6 class Median 7 8 public: 9 Median() = default; 10 int get() 11 12 return median; 13 14 void insert(int i) 15 16 if (median_count == 0) 17 18 median = i; 19 median_count = 1; 20 21 else if (i < median) 22 ++small[i], ++small_count; 23 else if (i > median) 24 ++large[i], ++large_count; 25 else 26 ++median_count; 27 adjust(); 28 29 void erase(int i) 30 31 if (i < median) 32 33 --small[i], --small_count; 34 if (small[i] == 0) 35 small.erase(i); 36 37 else if (i > median) 38 39 --large[i], --large_count; 40 if (large[i] == 0) 41 large.erase(i); 42 43 else 44 --median_count; 45 adjust(); 46 47 private: 48 std::map<int, int, std::greater<int>> small; 49 int small_count = 0; 50 std::map<int, int> large; 51 int large_count = 0; 52 int median; 53 int median_count = 0; 54 void small_to_median() 55 56 median = small.begin()->first; 57 median_count = small.begin()->second; 58 small.erase(small.begin()); 59 small_count -= median_count; 60 61 void large_to_median() 62 63 median = large.begin()->first; 64 median_count = large.begin()->second; 65 large.erase(large.begin()); 66 large_count -= median_count; 67 68 void median_to_small() 69 70 small[median] = median_count; 71 small_count += median_count; 72 73 void median_to_large() 74 75 large[median] = median_count; 76 large_count += median_count; 77 78 void adjust() 79 80 if (median_count == 0) 81 82 if (small_count < large_count) 83 large_to_median(); 84 else if (small_count) 85 small_to_median(); 86 87 else if (small_count + median_count < large_count) 88 89 median_to_small(); 90 large_to_median(); 91 92 else if (small_count >= median_count + large_count) 93 94 median_to_large(); 95 small_to_median(); 96 97 98 ; 99 100 class Stack 101 102 public: 103 Stack() = default; 104 void push(int i) 105 106 stack_.push(i); 107 median_.insert(i); 108 109 void pop() 110 111 if (stack_.empty()) 112 std::cout << "Invalid"; 113 else 114 115 int i = stack_.top(); 116 stack_.pop(); 117 std::cout << i; 118 median_.erase(i); 119 120 std::cout << std::endl; 121 122 void median() 123 124 if (stack_.empty()) 125 std::cout << "Invalid"; 126 else 127 128 std::cout << median_.get(); 129 130 std::cout << std::endl; 131 132 private: 133 std::stack<int> stack_; 134 Median median_; 135 ; 136 137 int main() 138 139 int count; 140 std::cin >> count; 141 Stack stack; 142 for (int i = 0; i != count; ++i) 143 144 std::string instr; 145 std::cin >> instr; 146 if (instr == "Push") 147 148 int i; 149 std::cin >> i; 150 stack.push(i); 151 152 else if (instr == "Pop") 153 stack.pop(); 154 else 155 stack.median(); 156 157
这个算法挺复杂的。客户维护一个 Stack 实例,它维护一个 Median 实例,两个都是我自己写的类。Median 中包含两个 std::map<int, int> 实例,分别储存比中位数小的和比中位数大的数。核心算法是 Median::adjust() ,它通过调整两边内容,维护中位数的正确性。不想细说了,看代码吧,只涉及到 std::map 的一些基本操作。
因为两次调整之间只有一个操作,所以可以保证调整一次就好了。
值得吐槽的一点是,C++的输入输出在这道题中比C慢了100ms。然而,算法不对,输入输出再快,也要超时。PAT好像没什么卡输入输出时间的题,毕竟世上除了C和C++还有好多编程语言,要考虑它们的感受。
写完了发现其他博客里没有用这么烦的方法,好像用了什么树状数组,我不会。
1 try 2 3 learn_queue.push("树状数组"); 4 5 catch(...) 6 7 std::cout << "快去睡觉" << std::endl; 8 9 10 -------------------------------------------------------------------------------- 11 快去睡觉 12 Program exited with code 0...
正好提到树了,下一篇就写树吧。
以上是关于PAT甲级题分类汇编——理论的主要内容,如果未能解决你的问题,请参考以下文章