[NOI2017] 蚯蚓排队

GitHub 跳转原题关系图返回列表

按被询问到的每个 k 分开离线模拟，只维护该 k 的向后串计数；合并分裂时只更新边界附近 k-1 个起点。

OJ: luogu

题目 ID: P3823

难度:NOI/NOI+/CTSC

标签:字符串哈希链表离线计数建模

日期: 2026-06-21 14:25

题意

有 $n$ 只蚯蚓，每只蚯蚓有一个长度数字 $1 \dots 6$ 。

初始时每只蚯蚓单独成队。之后有三种操作：

把 $i$ 所在队伍和 $j$ 所在队伍接起来，让 $j$ 紧挨在 $i$ 后面
把 $i$ 和它后面的那只蚯蚓断开
给一个数字串 $s$ 和一个 $k$ ，设 $f(t)$ 表示当前所有蚯蚓里，向后看最近 $k$ 只蚯蚓恰好形成字符串 $t$ 的起点数量，询问 $s$ 的所有长度为 $k$ 的连续子串 $t$ 的 $f(t)$ 乘积

要求输出每个第三类操作的答案。

思路

先看一个可以直接验证想法的朴素解：

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75#include <bits/stdc++.h>
using namespace std;

const int MOD = 998244353;
const int MAXN = 205;

int n, m;
int worm_len[MAXN];
int pre_node[MAXN], nxt_node[MAXN];

string forward_string(int u, int k) {
    string res = "";
    while (u != 0 && k > 0) {
        res.push_back(char('0' + worm_len[u]));
        u = nxt_node[u];
        k--;
    }
    if (k > 0) {
        return "";
    }
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> worm_len[i];
        pre_node[i] = nxt_node[i] = 0;
    }

    for (int opi = 1; opi <= m; opi++) {
        int type;
        cin >> type;
        if (type == 1) {
            int i, j;
            cin >> i >> j;
            nxt_node[i] = j;
            pre_node[j] = i;
        }
        else if (type == 2) {
            int i;
            cin >> i;
            int x = nxt_node[i];
            nxt_node[i] = 0;
            if (x != 0) {
                pre_node[x] = 0;
            }
        }
        else {
            string s;
            int k;
            cin >> s >> k;

            map<string, int> cnt;
            for (int i = 1; i <= n; i++) {
                string t = forward_string(i, k);
                if (!t.empty()) {
                    cnt[t]++;
                }
            }

            long long answer = 1;
            for (int i = 0; i + k <= (int)s.size(); i++) {
                string t = s.substr(i, k);
                answer = answer * cnt[t] % MOD;
            }
            cout << answer << '\n';
        }
    }

    return 0;
}

如果每次询问都暴力扫所有蚯蚓，重新统计所有长度为 $k$ 的向后串，复杂度一定爆炸。

这题真正关键的地方有两个：

$k \leqslant 50$ 很小
一次合并或分裂，真正受影响的起点只会出现在断点附近

我们先固定某一个 $k$ 来看。

对于这个固定的 $k$ ，每只蚯蚓最多只会贡献一个"向后 $k$ 串"。
于是我们只需要维护每个长度为 $k$ 的字符串当前出现了多少次。

再看修改操作。

假设把一条队伍的尾巴 $i$ 和另一条队伍的头 $j$ 接起来。
队伍内部原来已经存在的长度 $k$ 串都不会变，只有左边队尾附近最多 $k-1$ 个起点，原来因为后面不够长没有形成完整长度 $k$ 串，现在可能跨过新边界形成新的长度 $k$ 串。

分裂也是同理，只会让边界左侧最多 $k-1$ 个起点失去原来跨边界的长度 $k$ 串。

所以：

合并时，只需要给边界附近新出现的长度 $k$ 串计数 $+1$
分裂时，只需要把边界附近消失的长度 $k$ 串计数 $-1$

接下来还有一个重要观察：

不同询问的 $k$ 彼此独立。
固定 $k=3$ 时维护的是所有长度为 $3$ 的串计数；固定 $k=5$ 时维护的是长度为 $5$ 的串计数，它们互不干扰。

因此可以把所有询问按 $k$ 离线分组：

先读入全部操作
对每个真正出现过的 $k$
从初始状态重新模拟一遍所有操作
只在这一遍里维护这个 $k$ 的计数
遇到同样 $k$ 的询问就直接回答

固定某个 $k$ 时：

合并/分裂的更新量是 $O(k)$
询问只要对 $s$ 做长度 $k$ 的滑动窗口，用哈希表查每个窗口当前出现次数即可

代码里用双向链表维护队伍关系，用一个精确的 3-bit 打包键来表示长度 $k$ 的数字串，避免哈希冲突。

代码

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318#include <bits/stdc++.h>
using namespace std;

const int MOD = 998244353;
const int MAXN = 200005;
const int MAXK = 55;
const int HASH_SIZE = 1 << 20;

struct Key {
    unsigned long long x0, x1, x2;

    bool operator==(const Key &other) const {
        return x0 == other.x0 && x1 == other.x1 && x2 == other.x2;
    }
};

struct HashNode {
    Key key;
    int value;
    int next;
};

struct HashTable {
    int head[HASH_SIZE];
    vector<HashNode> nodes;
    vector<int> free_list;

    void init() {
        memset(head, -1, sizeof(head));
        nodes.clear();
        free_list.clear();
        nodes.reserve(400000);
        free_list.reserve(200000);
    }

    unsigned int hash_key(const Key &key) const {
        unsigned long long h = key.x0 * 1000003ULL;
        h ^= key.x1 * 1000033ULL;
        h ^= key.x2 * 1000211ULL;
        h ^= h >> 32;
        return (unsigned int)(h & (HASH_SIZE - 1));
    }

    int get(const Key &key) const {
        unsigned int bucket = hash_key(key);
        for (int i = head[bucket]; i != -1; i = nodes[i].next) {
            if (nodes[i].key == key) {
                return nodes[i].value;
            }
        }
        return 0;
    }

    void add(const Key &key, int delta) {
        unsigned int bucket = hash_key(key);
        int prev = -1;
        for (int i = head[bucket]; i != -1; i = nodes[i].next) {
            if (nodes[i].key == key) {
                nodes[i].value += delta;
                if (nodes[i].value == 0) {
                    if (prev == -1) {
                        head[bucket] = nodes[i].next;
                    }
                    else {
                        nodes[prev].next = nodes[i].next;
                    }
                    free_list.push_back(i);
                }
                return;
            }
            prev = i;
        }

        if (delta <= 0) {
            return;
        }

        int id;
        if (!free_list.empty()) {
            id = free_list.back();
            free_list.pop_back();
            nodes[id].key = key;
            nodes[id].value = delta;
            nodes[id].next = head[bucket];
        }
        else {
            id = (int)nodes.size();
            nodes.push_back({key, delta, head[bucket]});
        }
        head[bucket] = id;
    }
};

struct Operation {
    int type;
    int a, b;
    int k;
    int id;
    string s;
};

int n, m;
int worm_len[MAXN];
vector<Operation> ops;
vector<int> query_k_list;
vector<int> query_answer;
bool need_k[MAXK];

int pre_node[MAXN], nxt_node[MAXN];
int left_digits[MAXK], right_digits[MAXK], concat_digits[MAXK * 2];

unsigned long long mask0, mask1, mask2;

void clear_key(Key &key) {
    key.x0 = key.x1 = key.x2 = 0;
}

unsigned long long build_mask(int bits) {
    if (bits <= 0) {
        return 0;
    }
    if (bits >= 64) {
        return ~0ULL;
    }
    return (1ULL << bits) - 1;
}

void set_key_mask(int k) {
    int total_bits = 3 * k;
    mask0 = build_mask(min(total_bits, 64));
    mask1 = build_mask(min(max(total_bits - 64, 0), 64));
    mask2 = build_mask(min(max(total_bits - 128, 0), 64));
}

void append_digit(Key &key, int digit) {
    unsigned long long nx2 = (key.x2 << 3) | (key.x1 >> 61);
    unsigned long long nx1 = (key.x1 << 3) | (key.x0 >> 61);
    unsigned long long nx0 = (key.x0 << 3) | (unsigned long long)digit;
    key.x0 = nx0 & mask0;
    key.x1 = nx1 & mask1;
    key.x2 = nx2 & mask2;
}

int get_left_digits(int u, int limit, int out[]) {
    int tmp[MAXK];
    int cnt = 0;
    while (u != 0 && cnt < limit) {
        tmp[cnt++] = worm_len[u];
        u = pre_node[u];
    }
    for (int i = 0; i < cnt; i++) {
        out[i] = tmp[cnt - 1 - i];
    }
    return cnt;
}

int get_right_digits(int u, int limit, int out[]) {
    int cnt = 0;
    while (u != 0 && cnt < limit) {
        out[cnt++] = worm_len[u];
        u = nxt_node[u];
    }
    return cnt;
}

void update_cross_boundary(int left_tail, int right_head, int k, int delta, HashTable &counter) {
    if (k == 1 || left_tail == 0 || right_head == 0) {
        return;
    }

    int len_left = get_left_digits(left_tail, k - 1, left_digits);
    int len_right = get_right_digits(right_head, k - 1, right_digits);
    int total = len_left + len_right;
    if (total < k) {
        return;
    }

    for (int i = 0; i < len_left; i++) {
        concat_digits[i] = left_digits[i];
    }
    for (int i = 0; i < len_right; i++) {
        concat_digits[len_left + i] = right_digits[i];
    }

    int start_count = min(len_left, total - k + 1);
    if (start_count <= 0) {
        return;
    }

    Key key;
    clear_key(key);
    for (int i = 0; i < k; i++) {
        append_digit(key, concat_digits[i]);
    }
    counter.add(key, delta);

    for (int start = 1; start < start_count; start++) {
        append_digit(key, concat_digits[start + k - 1]);
        counter.add(key, delta);
    }
}

int query_string_product(const string &s, int k, const HashTable &counter) {
    for (int i = 0; i < (int)s.size(); i++) {
        if (s[i] < '1' || s[i] > '6') {
            return 0;
        }
    }

    Key key;
    clear_key(key);
    for (int i = 0; i < k; i++) {
        append_digit(key, s[i] - '0');
    }

    long long answer = counter.get(key);
    if (answer == 0) {
        return 0;
    }

    for (int i = k; i < (int)s.size(); i++) {
        append_digit(key, s[i] - '0');
        int ways = counter.get(key);
        if (ways == 0) {
            return 0;
        }
        answer = answer * ways % MOD;
    }
    return (int)answer;
}

void simulate_one_k(int k) {
    set_key_mask(k);

    for (int i = 1; i <= n; i++) {
        pre_node[i] = 0;
        nxt_node[i] = 0;
    }

    HashTable counter;
    counter.init();

    if (k == 1) {
        for (int i = 1; i <= n; i++) {
            Key key;
            clear_key(key);
            append_digit(key, worm_len[i]);
            counter.add(key, 1);
        }
    }

    for (int idx = 0; idx < (int)ops.size(); idx++) {
        Operation &op = ops[idx];
        if (op.type == 1) {
            update_cross_boundary(op.a, op.b, k, 1, counter);
            nxt_node[op.a] = op.b;
            pre_node[op.b] = op.a;
        }
        else if (op.type == 2) {
            int right_head = nxt_node[op.a];
            update_cross_boundary(op.a, right_head, k, -1, counter);
            if (right_head != 0) {
                pre_node[right_head] = 0;
            }
            nxt_node[op.a] = 0;
        }
        else if (op.k == k) {
            query_answer[op.id] = query_string_product(op.s, k, counter);
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> worm_len[i];
    }

    ops.reserve(m);
    int query_cnt = 0;
    for (int i = 1; i <= m; i++) {
        Operation op;
        cin >> op.type;
        op.id = -1;
        op.a = op.b = op.k = 0;
        op.s.clear();

        if (op.type == 1) {
            cin >> op.a >> op.b;
        }
        else if (op.type == 2) {
            cin >> op.a;
        }
        else {
            cin >> op.s >> op.k;
            op.id = query_cnt++;
            if (!need_k[op.k]) {
                need_k[op.k] = true;
                query_k_list.push_back(op.k);
            }
        }
        ops.push_back(op);
    }

    query_answer.assign(query_cnt, 0);
    for (int i = 0; i < (int)query_k_list.size(); i++) {
        simulate_one_k(query_k_list[i]);
    }

    for (int i = 0; i < query_cnt; i++) {
        cout << query_answer[i] << '\n';
    }

    return 0;
}

复杂度

设被询问到的不同 $k$ 个数为 $D$ 。

对某个固定的 $k$ ：

每次合并/分裂只更新边界附近 $O(k)$ 个起点
每次询问扫描一次字符串 $s$

所以总复杂度可以看成：

$O((\text{合并数} + \text{分裂数}) \times \text{sum}(k))$
再加上所有询问字符串总长度 $O(\text{sum} |s|)$

其中 $\text{sum}(k)$ 只对真正出现过的 $k$ 求和，最大也就是 $1+2+\dots+50=1275$ 。

总结

这题最难的不是链表，而是看出"固定一个 $k$ 单独维护"这个离线思路。

一旦按 $k$ 拆开，问题就变成：

用链表表示队伍
用边界局部更新维护长度 $k$ 串计数
用滑动窗口回答查询

核心就是"修改只影响边界附近，且不同 $k$ 可以分治处理"。

总结

P3823 [NOI2017] 蚯蚓排队

题目描述

蚯蚓幼儿园有 $n$ 只蚯蚓。幼儿园园长神刀手为了管理方便，时常让这些蚯蚓们列队表演。

所有蚯蚓用从 $1$ 到 $n$ 的连续正整数编号。每只蚯蚓的长度可以用一个正整数表示，根据入园要求，所有蚯蚓的长度都不超过 $6$ 。神刀手希望这些蚯蚓排成若干个队伍，初始时，每只蚯蚓各自排成一个仅有一只蚯蚓的队伍，该蚯蚓既在队首，也在队尾。

神刀手将会依次进行 $m$ 次操作，每个操作都是以下三种操作中的一种：

给出 $i$ 和 $j$ ，令 $i$ 号蚯蚓与 $j$ 号蚯蚓所在的两个队伍合并为一个队伍，具体来说，令 $j$ 号蚯蚓紧挨在 $i$ 号蚯蚓之后，其余蚯蚓保持队伍的前后关系不变。
给出 $i$ ，令 $i$ 号蚯蚓与紧挨其后的一只蚯蚓分离为两个队伍，具体来说，在分离之后， $i$ 号蚯蚓在其中一个队伍的队尾，原本紧挨其后的那一只蚯蚓在另一个队伍的队首，其余蚯蚓保持队伍的前后关系不变。
给出一个正整数 $k$ 和一个长度至少为 $k$ 的数字串 $s$ ，对于 $s$ 的每个长度为 $k$ 的连续子串 $t$ （这样的子串共有 $|s|-k+1$ 个，其中 $|s|$ 为 $s$ 的长度），定义函数 $f(t)$ ，询问所有这些 $f(t)$ 的乘积对 $998244353$ 取模后的结果。其中 $f(t)$ 的定义如下：

对于当前的蚯蚓队伍，定义某个蚯蚓的向后 $k$ 数字串为：从该蚯蚓出发，沿队伍的向后方向，寻找最近的 $k$ 只蚯蚓（包括其自身），将这些蚯蚓的长度视作字符连接而成的数字串；如果这样找到的蚯蚓不足 $k$ 只，则其没有向后 $k$ 数字串。例如蚯蚓的队伍为 $10$ 号蚯蚓在队首，其后是 $22$ 号蚯蚓，其后是 $3$ 号蚯蚓（为队尾），这些蚯蚓的长度分别为 $4$ 、 $5$ 、 $6$ ，则 $10$ 号蚯蚓的向后 $3$ 数字串为 456， $22$ 号蚯蚓没有向后 $3$ 数字串，但其向后 $2$ 数字串为 56，其向后 $1$ 数字串为 5。

而 $f(t)$ 表示所有蚯蚓中，向后 $k$ 数字串恰好为 $t$ 的蚯蚓只数。

输入格式

输入文件的第一行有两个正整数 $n,m$ ，分别表示蚯蚓的只数与操作次数。

第二行包含 $n$ 个不超过 $6$ 的正整数，依次表示编号为 $1,2,\dots,n$ 的蚯蚓的长度。

接下来 $m$ 行，每行表示一个操作。每个操作的格式可以为：

1 $i$ $j$ （ $1 \leq i, j \leq n$ ）表示：令 $i$ 号与 $j$ 号蚯蚓所在的两个队伍合并为一个队伍，新队伍中， $j$ 号蚯蚓紧挨在 $i$ 号蚯蚓之后。保证在此操作之前， $i$ 号蚯蚓在某个队伍的队尾， $j$ 号蚯蚓在某个队伍的队首，且两只蚯蚓不在同一个队伍中。
2 $i$ （ $1 \leq i \leq n$ ）表示：令 $i$ 号蚯蚓与紧挨其后一个蚯蚓分离为两个队伍。保证在此操作之前， $i$ 号蚯蚓不是某个队伍的队尾。
3 $s$ $k$ （ $k$ 为正整数， $s$ 为一个长度至少为 $k$ 的数字串）表示：询问 $s$ 的每个长度为 $k$ 的子串 $t$ 的 $f(t)$ 的乘积，对 $998244353$ 取模的结果。 $f(t)$ 的定义见题目描述。

同一行输入的相邻两个元素之间，用恰好一个空格隔开。

输入文件可能较大，请不要使用过于缓慢的读入方式。

输出格式

依次对于每个形如 3 s k 的操作，输出一行，仅包含一个整数，表示询问的结果。

输入输出样例 #1

输入 #1

text

输出 #1

text

输入输出样例 #2

输入 #2

text

1
2
3
4
5
6
7
8
9
10
11
122 10
6 6
3 666666 1
1 1 2
3 666666 2
3 666666 4
3 666666666666666666666666666666 1
2 1
1 2 1
3 666666 2
3 666666 4
3 666666666666666666666666666666 1

输出 #2

text

说明/提示

保证 $n \leq 2 \times 10^{5}$ ， $m \leq 5 \times 10^{5}$ ， $k \leq 50$ 。

设 $\sum |s|$ 为某个输入文件中所有询问的 $s$ 的长度总和，则 $\sum |s| \leq 10^{7}$ 。

设 $c$ 为某个输入文件中形如 2 i 的操作的次数，则 $c \leq 10^{3}$ 。

每个测试点的详细信息见下表：

测试点编号	$n$	$m$	$k$	$\sum \|s\|$	$c$	全为 $\texttt{1}$
1	$=1$	$\leq 10^{3}$	$=1$	$\leq 10^{3}$	$=0$	No
2	$\leq 20$	$\leq 40$	$\leq 10$	$\leq 10^{3}$	$=0$	No
3	$\leq 150$	$\leq 2,000$	$\leq 50$	$\leq 10^{3}$	$\leq 10^{3}$	No
4	$\leq 500$	$\leq 600$	$\leq 50$	$\leq 10^{3}$	$=0$	No
5	$\leq 10^{3}$	$\leq 2,000$	$\leq 50$	$\leq 10^{3}$	$\leq 10^{3}$	No
6	$\leq 5 \times 10^{4}$	$\leq 6 \times 10^{4}$	$\leq 5$	$\leq 5 \times 10^{4}$	$\leq 10^{3}$	No
7	$\leq 5 \times 10^{4}$	$\leq 6 \times 10^{4}$	$\leq 50$	$\leq 5 \times 10^{4}$	$=0$	Yes
8	$\leq 5 \times 10^{4}$	$\leq 6 \times 10^{4}$	$\leq 50$	$\leq 5 \times 10^{4}$	$=0$	No
9	$\leq 5 \times 10^{4}$	$\leq 6 \times 10^{4}$	$\leq 50$	$\leq 5 \times 10^{4}$	$\leq 10^{3}$	No
10	$\leq 5 \times 10^{4}$	$\leq 8 \times 10^{4}$	$\leq 50$	$\leq 2.5 \times 10^{6}$	$=0$	No
11	$\leq 5 \times 10^{4}$	$\leq 8 \times 10^{4}$	$\leq 50$	$\leq 2.5 \times 10^{6}$	$\leq 10^{3}$	No
12	$\leq 10^{5}$	$\leq 1.1 \times 10^{5}$	$\leq 6$	$\leq 10^{5}$	$\leq 10^{3}$	No
13	$\leq 10^{5}$	$\leq 1.1 \times 10^{5}$	$\leq 50$	$\leq 10^{5}$	$=0$	Yes
14	$\leq 10^{5}$	$\leq 1.1 \times 10^{5}$	$\leq 50$	$\leq 10^{5}$	$=0$	No
15	$\leq 10^{5}$	$\leq 1.1 \times 10^{5}$	$\leq 50$	$\leq 10^{5}$	$\leq 10^{3}$	No
16	$\leq 10^{5}$	$\leq 1.5 \times 10^{5}$	$\leq 50$	$\leq 5 \times 10^{6}$	$=0$	No
17	$\leq 10^{5}$	$\leq 1.5 \times 10^{5}$	$\leq 50$	$\leq 5 \times 10^{6}$	$\leq 10^{3}$	No
18	$\leq 2 \times 10^{5}$	$\leq 5 \times 10^{5}$	$=1$	$\leq 10^{7}$	$=0$	No
19	$\leq 2 \times 10^{5}$	$\leq 5 \times 10^{5}$	$=1$	$\leq 10^{7}$	$\leq 10^{3}$	No
20	$\leq 2 \times 10^{5}$	$\leq 2.5 \times 10^{5}$	$\leq 7$	$\leq 2 \times 10^{5}$	$\leq 10^{3}$	No
21	$\leq 2 \times 10^{5}$	$\leq 2.5 \times 10^{5}$	$\leq 50$	$\leq 2 \times 10^{5}$	$=0$	Yes
22	$\leq 2 \times 10^{5}$	$\leq 2.5 \times 10^{5}$	$\leq 50$	$\leq 2 \times 10^{5}$	$=0$	No
23	$\leq 2 \times 10^{5}$	$\leq 2.5 \times 10^{5}$	$\leq 50$	$\leq 2 \times 10^{5}$	$\leq 10^{3}$	No
24	$\leq 2 \times 10^{5}$	$\leq 3 \times 10^{5}$	$\leq 50$	$\leq 10^{7}$	$=0$	No
25	$\leq 2 \times 10^{5}$	$\leq 3 \times 10^{5}$	$\leq 50$	$\leq 10^{7}$	$\leq 10^{3}$	No

如果一个测试点的“全为1”的一列为“Yes”，表示该测试点的所有蚯蚓的长度均为 1，并且所有询问串 $s$ 的每一位也均为1。

[NOI2017] 蚯蚓排队

目录

题意

思路

代码

复杂度

总结

总结