线性类，指线性时间复杂度可以完成的题。在1051到1100中，有7道：
| 题号 | 标题 | 分数 | 大意 | 时间 |
| 1054 | The Dominant Color | 20 | 寻找出现最多的数 | 200ms |
| 1061 | Dating | 20 | 寻找字符串中相同字符 | 200ms |
| 1071 | Speech Patterns | 25 | 寻找出现最多的单词 | 300ms |
| 1077 | Kuchiguse | 20 | 字符串共同后缀 | 150ms |
| 1082 | Read Number in Chinese | 25 | 中文读数 | 400ms |
| 1084 | Broken Keyboard | 20 | 比较两序列的差异 | 200ms |
| 1095 | Cars on Campus | 30 | 模拟车辆进出 | 300ms |
可以看到线性题一般分数不高，一般只有模拟事件的题会出30分，但也不难。
这种题一般一看就会做（最大子列和除外），难度一般在细节处理（所有PAT题都是）和时间常数上。
关于细节处理，分数低的题，本来就简单，做的时候容易想起一些细节问题，在第一次提交之前就处理好了。
关于时间限制，其他题时间限制一般都是400ms，但线性类时间更严格的比较多，这时候就要小心常数了。
仔细阅读了一下7道题，决定做1054、1071、1082和1095一共4道。
1054：
放在线性分类下，就要用线性方法做。用 std::map 做起来一看就很简单，为了挑战自己，换一种方法。
大致思路是每个维度（颜色）建立一个散列表，表中存放指向下一个维度的散列表的指针，最后一个维度存放数据。
代码如下：
1 #include <iostream>
2 #include <vector>
3 #include <memory>
4
5 template <typename T>
6 using Pointer_vector = std::shared_ptr<std::vector<T>>;
7
8 int main()
9 {
10 int m, n, total;
11 std::cin >> m >> n;
12 total = m * n;
13 using Blue = int;
14 using Green = Pointer_vector<Blue>;
15 using Red = Pointer_vector<Green>;
16 std::vector<Red> data(256);
17 for (int cnt = 0; cnt != total; ++cnt)
18 {
19 int color;
20 std::cin >> color;
21 int red = color >> 16;
22 int green = (color >> 8) % 256;
23 int blue = color % 256;
24 auto& red_data = data[red];
25 if (!red_data)
26 red_data = Red(new std::vector<Green>(256));
27 auto& green_data = (*red_data)[green];
28 if (!green_data)
29 green_data = Green(new std::vector<Blue>(256));
30 auto& blue_data = (*green_data)[blue];
31 ++blue_data;
32 }
33 try
34 {
35 for (int r = 0; r != 256; ++r)
36 if (data[r])
37 for (int g = 0; g != 256; ++g)
38 if ((*data[r])[g])
39 for (int b = 0; b != 256; ++b)
40 if ((*(*data[r])[g])[b] > total / 2)
41 throw (r << 16) + (g << 8) + b;
42 }
43 catch (int res)
44 {
45 std::cout << res;
46 }
47 }
对于多重循环要 break 的算法我一般用异常来做流控。这是一种备受争议的做法，因此我又想着用输出和 return 替换掉原来的 throw 语句，没想到竟然超时了！加了优化也没用。
不是说 try block会导致性能下降的吗？为什么加了异常处理以后性能反而提高？
想不通。我又用 std::map 实现了一个算法：
1 #include <iostream>
2 #include <map>
3
4 #pragma GCC optimize(O3)
5
6 int main()
7 {
8 int m, n, total;
9 std::cin >> m >> n;
10 total = m * n;
11 std::map<int, int> map;
12 for (int cnt = 0; cnt != total; ++cnt)
13 {
14 int color;
15 std::cin >> color;
16 ++map[color];
17 }
18 for (const auto& pair : map)
19 if (pair.second > total / 2)
20 {
21 std::cout << pair.first;
22 return 0;
23 }
24 return 0;
25 }
一开始当然是没有 #pragma 那一行的，但是超时了，后来加上了才AC。
这道题告诉我们，线性题对时间要求真的很高。或许用 scanf 代替 std::cin 能让原本超时的AC吧，我没试过。
1071：
字符串的线性处理、std::map 的使用，这道题难度就这么多了。代码如下：
1 #include <iostream>
2 #include <string>
3 #include <map>
4 #include <cctype>
5
6 int main()
7 {
8 std::map<std::string, int> words;
9 std::string string;
10 while (1)
11 {
12 char c = std::cin.get();
13 if (std::isalnum(c))
14 string.push_back(std::tolower(c));
15 else
16 if (!string.empty())
17 {
18 ++words[string];
19 string.clear();
20 }
21 if (c == ‘\n‘)
22 break;
23 }
24 auto max = words.cbegin();
25 for (auto iter = words.cbegin(); iter != words.cend(); ++iter)
26 if (iter->second > max->second)
27 max = iter;
28 std::cout << max->first << ‘ ‘ << max->second << std::endl;
29 }
值得杠一杠的是这道题是不是线性。
首先，输入是O(n)，输出是O(1)，都在线性范围内。
假设一共有a种单词，对 std::map 的操作是O(a·loga)；a种单词连起来的最小长度是O(a·loga)，n一定大于这个长度，因此这道题是线性的。
1082：
呵，这道题就是在考数学。但我没有把它放到数学那一类中，因为这是小学数学。
一开始觉得很难，但只要把10000以内的数字怎么读搞清楚了，这道题就差不多了。代码如下：
1 #include <iostream>
2 #include <string>
3 #include <vector>
4
5 std::vector<std::string> data;
6
7 const char pinyin[10][5] =
8 {
9 "ling",
10 "yi",
11 "er",
12 "san",
13 "si",
14 "wu",
15 "liu",
16 "qi",
17 "ba",
18 "jiu"
19 };
20
21 void chinese(int num)
22 {
23 int qian = num / 1000;
24 num %= 1000;
25 int bai = num / 100;
26 num %= 100;
27 int shi = num / 10;
28 int ge = num % 10;
29 int digit = 0;
30 if (qian)
31 {
32 digit = 3;
33 data.push_back(pinyin[qian]);
34 data.push_back("Qian");
35 }
36 if (bai)
37 {
38 digit = 2;
39 data.push_back(pinyin[bai]);
40 data.push_back("Bai");
41 }
42 if (shi)
43 {
44 if (digit > 2)
45 data.push_back(pinyin[0]);
46 digit = 1;
47 data.push_back(pinyin[shi]);
48 data.push_back("Shi");
49 }
50 if (ge)
51 {
52 if (digit > 1)
53 data.push_back(pinyin[0]);
54 data.push_back(pinyin[ge]);
55 }
56 }
57
58 int main()
59 {
60 int num;
61 std::cin >> num;
62 if (num == 0)
63 {
64 std::cout << pinyin[0];
65 return 0;
66 }
67 if (num < 0)
68 {
69 num = -num;
70 data.push_back("Fu");
71 }
72 int yi = num / 100000000;
73 int wan = num % 100000000 / 10000;
74 int ge = num % 10000;
75 int seg = 0;
76 if (yi)
77 {
78 seg = 2;
79 data.push_back(pinyin[yi]);
80 data.push_back("Yi");
81 }
82 if (wan)
83 {
84 if (wan < 1000 && seg > 1)
85 data.push_back(pinyin[0]);
86 seg = 1;
87 chinese(wan);
88 data.push_back("Wan");
89 }
90 if (ge)
91 {
92 if (ge < 1000 && seg > 0)
93 data.push_back(pinyin[0]);
94 chinese(ge);
95 }
96 int end = data.size() - 1;
97 for (int i = 0; i != end; ++i)
98 std::cout << data[i] << ‘ ‘;
99 std::cout << data[end];
100 }
这是我第一次用拼音来命名变量。我也不想这样，但谁让这道题中文背景这么明显呢？
1095：
这道题要求模拟车辆进出校园的过程，这类模拟一个过程的题目，我称之为模拟类题。
模拟类题的一个通用方法就是以时间为变量循环，但是这道题写着写着就用上另一种方法了，就是以对象为变量循环，这里的对象就是车辆进出记录。
题目逻辑比较复杂，大致可以分为3个步骤：
第一步，读取所有记录，并按时间顺序排序，然后按记录类型配对；
第二步，读取查询的时间，并模拟车辆进出的过程，这是模拟类题的核心（但在本题中占的比例不大）；
第三步，找出最长的停车时间，并输出对应的车牌号（老司机开车！）。
梳理完这堆逻辑以后就直接上代码吧：
1 #include <iostream>
2 #include <iomanip>
3 #include <string>
4 #include <vector>
5 #include <map>
6 #include <algorithm>
7
8 int read_time()
9 {
10 int res, temp;
11 std::cin >> temp;
12 res = temp * 3600;
13 std::cin.get();
14 std::cin >> temp;
15 res += temp * 60;
16 std::cin.get();
17 std::cin >> temp;
18 res += temp;
19 return res;
20 }
21
22 void print_time(int time)
23 {
24 std::cout << std::setfill(‘0‘);
25 std::cout << std::setw(2) << time / 3600 << ‘:‘;
26 time %= 3600;
27 std::cout << std::setw(2) << time / 60 << ‘:‘;
28 std::cout << std::setw(2) << time % 60;
29 }
30
31 enum class Status
32 {
33 in, out
34 };
35
36 struct Record
37 {
38 std::string plate;
39 int time;
40 Status status;
41 bool paired = false;
42 int parking;
43 };
44
45 int main()
46 {
47 int n, k;
48 std::cin >> n >> k;
49 std::vector<Record> records(n);
50 for (auto& r : records)
51 {
52 std::cin >> r.plate;
53 r.time = read_time();
54 std::string str;
55 std::cin >> str;
56 r.status = str == "in" ? Status::in : Status::out;
57 }
58 std::sort(records.begin(), records.end(), [](const Record& _lhs, const Record& _rhs) {
59 return _lhs.time < _rhs.time;
60 });
61 for (auto rec = records.begin(); rec != records.end(); ++rec)
62 if (rec->status == Status::in)
63 for (auto iter = rec + 1; iter != records.end(); ++iter)
64 if (iter->plate == rec->plate && iter->status == Status::in)
65 break;
66 else if (iter->plate == rec->plate && iter->status == Status::out)
67 {
68 rec->paired = iter->paired = true;
69 rec->parking = iter->time - rec->time;
70 break;
71 }
72
73 auto iter = records.begin();
74 int count = 0;
75 for (int cnt = 0; cnt != k; ++cnt)
76 {
77 int time = read_time();
78 for (; iter != records.end() && iter->time <= time; ++iter)
79 if (iter->paired && iter->status == Status::in)
80 ++count;
81 else if (iter->paired && iter->status == Status::out)
82 --count;
83 std::cout << count << std::endl;
84 }
85
86 std::map<std::string, int> parking;
87 for (const auto& rec : records)
88 if (rec.paired && rec.status == Status::in)
89 parking[rec.plate] += rec.parking;
90 int longest = 0;
91 for (const auto& car : parking)
92 if (car.second > longest)
93 longest = car.second;
94 for (const auto& car : parking)
95 if (car.second == longest)
96 std::cout << car.first << ‘ ‘;
97 print_time(longest);
98 }
这道题放在线性类，是因为配对和模拟的算法都是线性的（其实是因为我看到它是模拟类就把它分给线性类了）。
总之，线性类题目难度不高，但坑不少，不仅有各种边界数据，还有卡时间常数的。
原文地址：https://www.cnblogs.com/jerry-fuyi/p/11258506.html
时间： 2024-10-02 02:14:19