理论这一类，是让我觉得特别尴尬的题，纯粹是为了考数据结构而考数据结构。看那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...
正好提到树了，下一篇就写树吧。
原文地址：https://www.cnblogs.com/jerry-fuyi/p/11450412.html
时间： 2024-11-08 02:16:15