Merge branch 'master' into dmst

Shell 排序是以它的发明者命名的，也称为缩小增量排序法。Shell 排序对不相邻的记录进行比较和移动：

本页面将简要介绍希尔排序。

1. 将待排序序列分为若干子序列（每个子序列的元素在原始数组中间距相同）

2. 对这些子序列进行插入排序

3. 减小每个子序列中元素之间的间距，重复上述过程直至间距减少为 1

## 简介

Shell 排序的复杂度和间距序列的选取（就是间距如何减小到 1）有关，比如“间距每次除以 3”的 Shell 排序的复杂度是 $O(n^{3/2})$ 。

希尔排序（英文：Shell sort），也称为缩小增量排序法，是 [插入排序](insertion-sort.md) 的一种改进版本。希尔排序以它的发明者希尔（英文：Donald Shell）命名。

## 工作原理

排序对不相邻的记录进行比较和移动：

1. 将待排序序列分为若干子序列（每个子序列的元素在原始数组中间距相同）；

2. 对这些子序列进行插入排序；

3. 减小每个子序列中元素之间的间距，重复上述过程直至间距减少为 1。

## 性质

### 稳定性

希尔排序是一种不稳定的排序算法。

### 时间复杂度

希尔排序的最优时间复杂度为 $O(n)$ 。

希尔排序的平均时间复杂度和最坏时间复杂度与间距序列的选取（就是间距如何减小到 1）有关，比如「间距每次除以 3」的希尔排序的时间复杂度是 $O(n^{3/2})$ 。已知最好的最坏时间复杂度为 $O(n \log^2n)$ 。

### 空间复杂度

希尔排序的空间复杂度为 $O(n)$ 。

## 实现

### C++[^ref1]

```cpp

template <typename T>

void shell_sort(T array[], int length) {

  int h = 1;

  while (h < length / 3) {

    h = 3 * h + 1;

  }

  while (h >= 1) {

    for (int i = h; i < length; i++) {

      for (int j = i; j >= h && array[j] < array[j - h]; j -= h) {

        std::swap(array[j], array[j - h]);

      }

    }

    h = h / 3;

  }

}

```

## 参考资料与注释

[^ref1]:  [希尔排序 - 维基百科，自由的百科全书](https://zh.wikipedia.org/wiki/%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F) 

-  [AtCoder](https://atcoder.jp/) ：日本 OJ，日文版里会有日本高校的比赛，英文内不会显示。题目有趣，质量较高。

-  [CodeChef](https://codechef.com/) ：印度 OJ，周期举办比赛。系统基于 SPOJ 的 Sphere Engine。

-  [Codeforces](https://codeforces.com/) ：俄罗斯 OJ，始于 2010 年，创始人是 [Mike Mirzayanov](https://www.linkedin.com/in/mike-mirzayanov-31772a93/) 。有多种系列的比赛，并支持个人出题、申请组织比赛。题目质量较高。

-  [CSES](https://cses.fi/problemset/) (Code Submission Evaluation System)，按专题划分的题库， [旨在](https://cses.fi/problemset/text/1810) 成为综合的高质量题库，目前只有 200 题，主要由 [Competitive Programmer’s Handbook](https://cses.fi/book/book.pdf) 作者 Antti Laaksonen 开发，始于 2013。

-  [CS Academy](https://csacademy.com/) 

-  [DMOJ](https://dmoj.ca/) 加拿大开源的 OJ，语言支持广；题库是各大比赛的存档，也有定期自行举办的比赛。

-  [HackerRank](https://www.hackerrank.com/) 有很多比赛

定义势能函数 $\Phi(S)=\sum\limits_{x\in S}\Phi(x)$ ，其中 $S$ 表示一整个并查集，而 $x$ 为并查集中的一个节点。定义 $\Phi(x)$ 为：

$$

\Phi(x)=\left\{

\begin{aligned}

&\alpha(n)\times rnk(x)& &rnk(x)=0\text{ 或 x为某棵树的根节点}&\\

&(\alpha(n)-level(x))\times rnk(x)-iter(x)& &otherwise&

\end{aligned}\right.

\Phi(x)=

\begin{cases}

\alpha(n)\times \mathit{rnk}(x)& \mathit{rnk}(x)=0\text{或}x\text{为某棵树的根节点}&\\

(\alpha(n)-\mathit{level}(x))\times \mathit{rnk}(x)-iter(x)& \mathit{otherwise}&

\end{cases}

$$

然后就是通过操作引起的势能变化来证明摊还时间复杂度为 $\Theta(\alpha(n))$ 啦。注意，这里我们讨论的 $union(x,y)$ 操作保证了 $x$ 和 $y$ 都是某个树的根，因此不需要额外执行 $find(x)$ 和 $find(y)$ 。

本文介绍和队列有关的数据结构及其应用。

本页面介绍和队列有关的数据结构及其应用。

## 队列

队列，英文名是 queue，在 C++ STL 中有 [std::queue](https://en.cppreference.com/w/cpp/container/queue) 和 [std::priority_queue](https://en.cppreference.com/w/cpp/container/priority_queue) 。

队列（queue）是一种具有「先进入队列的元素一定先出队列」性质的表。由于该性质，队列通常也被称为先进先出（first in first out）表，简称 FIFO 表。

先进入队列的元素一定先出队列，因此队列通常也被称为先进先出（first in first out）表，简称 FIFO 表。

C++ STL 中实现了 [队列 `std::queue` ](https://zh.cppreference.com/w/cpp/container/queue) 和 [优先队列 `std::priority_queue` ](https://zh.cppreference.com/w/cpp/container/priority_queue) 两个类，定义于头文件 [ `<queue>` ](https://zh.cppreference.com/w/cpp/header/queue) 中。

注： `std::stack` 和 `std::queue` 都是容器适配器，默认底层容器为 `std::deque` （双端队列）。

???+note

     `std::queue` 是容器适配器，默认的底层容器为双端队列 [ `std::deque` ](https://zh.cppreference.com/w/cpp/container/deque) 。

## 双端队列

## 队列模拟

双端队列是指一个可以在队首/队尾插入或删除元素的队列。相当于是栈与队列功能的结合。具体地，双端队列支持的操作有 4 个：

1. 在队首插入一个元素

2. 在队尾插入一个元素

3. 在队首删除一个元素

4. 在队尾删除一个元素

## 数组模拟队列

### 数组模拟队列

通常用一个数组模拟一个队列，用两个变量标记队列的首尾。

int q[SIZE], ql = 1, qr;

```

插入元素： `q[++qr]=x;` 

- 插入元素： `q[++qr]=x;` 

删除元素： `++ql;` 

- 删除元素： `++ql;` 

访问队首/队尾： `q[ql]` / `q[qr]` 

- 访问队首/队尾： `q[ql]` / `q[qr]` 

清空队列： `ql=1;qr=0;` 

- 清空队列： `ql=1;qr=0;` 

数组模拟双端队列是同理的。

### 双栈模拟队列

## 循环队列

还有一种冷门的方法是双栈模拟队列。

这样会导致一个问题：随着时间的推移，整个队列会向数组的尾部移动，一旦到达数组的最末端，即使数组的前端还有空闲位置，再进行入队操作也会导致溢出。（这种数组上实际有空闲位置而发生了上溢的现象称为是“假溢出”。

这种方法使用两个栈 F,S 模拟一个队列，其中 F 是队尾的栈，S 代表队首的栈，支持 push（在队尾插入），pop（在队首弹出）操作：

解决假溢出的办法是采用循环的方式来组织存放队列元素的数组，即将数组下标为 0 的位置看做是最后一个位置的后继。（ `x` 的后继为 `(x + 1) % Size` ）。这样就形成了循环队列。

- push：插入到栈 F 中。

- pop：如果 S 非空，让 S 弹栈；否则把 F 的元素倒过来压到 S 中（其实就是一个一个弹出插入，做完后是首位颠倒的），然后再让 S 弹栈。

## 双栈模拟队列

容易证明，每个元素只会进入/转移/弹出一次，均摊复杂度 $O(1)$ 。

其实不仅仅可以用数组模拟队列，还有一种冷门的方法是双栈模拟队列。

## 特殊的队列

我们使用两个栈 F,S 模拟一个队列，其中 F 是队尾的栈，S 代表队首的栈，支持 push（在队尾插入），pop（在队首弹出）操作：

### 双端队列

1. Push：插入到栈 F 中

2. Pop：如果 S 非空，让 S 弹栈；否则把 F 的元素倒过来压到 S 中（其实就是一个一个弹出插入，做完后是首位颠倒的），然后再让 S 弹栈。

双端队列是指一个可以在队首/队尾插入或删除元素的队列。相当于是栈与队列功能的结合。具体地，双端队列支持的操作有 4 个：

容易证明，每个元素只会进入/转移/弹出一次，均摊复杂度 $O(1)$ 。

- 在队首插入一个元素

- 在队尾插入一个元素

- 在队首删除一个元素

- 在队尾删除一个元素

有人问这个东西有什么用吗？参见下面这道题。这道题顺便可以给大家一个 **双栈模拟双端队列** 的方法。

数组模拟双端队列的方式与普通队列相同。

### 循环队列

使用数组模拟队列会导致一个问题：随着时间的推移，整个队列会向数组的尾部移动，一旦到达数组的最末端，即使数组的前端还有空闲位置，再进行入队操作也会导致溢出（这种数组里实际有空闲位置而发生了上溢的现象被称为“假溢出”）。

解决假溢出的办法是采用循环的方式来组织存放队列元素的数组，即将数组下标为 0 的位置看做是最后一个位置的后继。（数组下标为 `x` 的元素，它的后继为 `(x + 1) % SIZE` ）。这样就形成了循环队列。

## 例题

 [LOJ6515「雅礼集训 2018 Day10」贪玩蓝月](https://loj.ac/problem/6515) 

???+note "[LOJ6515「雅礼集训 2018 Day10」贪玩蓝月](https://loj.ac/problem/6515)"

    一个双端队列（deque），m 个事件：

> 一个双端队列（deque），m 个事件：

>

> 1. 在前端插入 (w,v)

> 2. 在后端插入 (w,v)

> 3. 删除前端的二元组

> 4. 删除后端的二元组

> 5.  给定 l,r，在当前 deque 中选择一个子集 S 使得 $\sum_{(w,v)\in S}w\bmod p\in[l,r]$ ，且最大化 $\sum_{(w,v)\in S}v$ .

>

>      $m\leq 5\times 10^4,p\leq 500$ .

    1. 在前端插入 (w,v)

    2. 在后端插入 (w,v)

    3. 删除前端的二元组

    4. 删除后端的二元组

    5.  给定 l,r，在当前 deque 中选择一个子集 S 使得 $\sum_{(w,v)\in S}w\bmod p\in[l,r]$ ，且最大化 $\sum_{(w,v)\in S}v$ .

### 离线算法

    $m\leq 5\times 10^4,p\leq 500$ .

??? note "解题思路"

    每个二元组是有一段存活时间的，因此对时间建立线段树，每个二元组做 log 个存活标记。因此我们要做的就是对每个询问，求其到根节点的路径上的标记的一个最优子集。显然这个可以 DP 做。 $f[S,j]$ 表示选择集合 S 中的物品余数为 j 的最大价值。（其实实现的时侯是有序的，直接 f[i,j]做）

    一共有 $O(m\log m)$ 个标记，因此这么做的话复杂度是 $O(mp\log m)$ 的。

### 在线算法

    ---

这是一个在线算法比离线算法快的神奇题目。而且还比离线的好写

    这是一个在线算法比离线算法快的神奇题目。而且还比离线的好写。

    上述离线算法其实是略微小题大做的，因为如果把题目的 deque 改成直接维护一个集合的话（即随机删除集合内元素），那么离线算法同样适用。既然是 deque，不妨在数据结构上做点文章。

### 栈

    ---

    如果题目中维护的数据结构是一个栈呢？

    f[i,j]=\max(f[i-1,j],f[i-1,(j-w_i)\bmod p]+v_i)

    $$

妥妥的背包啊

    妥妥的背包啊。

    删除的时侯直接指针前移即可。这样做的复杂度是 $O(mp)$ 的。

### 队列

    ---

    如果题目中维护的数据结构是队列？

有一种操作叫双栈模拟队列。这就是这个东西的用武之地。因为用栈是可以轻松维护 DP 过程的，而双栈模拟队列的复杂度是均摊 $O(1)$ 的，因此，复杂度仍是 $O(mp)$ .

    有一种操作叫双栈模拟队列。这就是这个东西的用武之地。因为用栈是可以轻松维护 DP 过程的，而双栈模拟队列的复杂度是均摊 $O(1)$ 的，因此，复杂度仍是 $O(mp)$ 。

### 双端队列

    ---

    回到原题，那么 Deque 怎么做？

类比推理，我们尝试用栈模拟双端队列，于是似乎把维护队列的方法扩展一下就可以了。但如果每次是全部转移栈中的元素的话，单次操作复杂度很容易退化为 $O(m)$ .

    类比推理，我们尝试用栈模拟双端队列，于是似乎把维护队列的方法扩展一下就可以了。但如果每次是全部转移栈中的元素的话，单次操作复杂度很容易退化为 $O(m)$ 。

于是乎，神仙的想一想，我们可以丢一半过去啊

    于是乎，神仙的想一想，我们可以丢一半过去啊。

    这样的复杂度其实均摊下来仍是常数级别。具体地说，丢一半指的是把一个栈靠近栈底的一半倒过来丢到另一个栈中。也就是说要手写栈以支持这样的操作。

### 丢一半的复杂度

    ---

    似乎可以用 [势能分析法](https://yhx-12243.github.io/OI-transit/records/cf601E.html) 证明。其实本蒟蒻有一个很仙的想法。我们考虑这个双栈结构的整体复杂度。m 个事件，我们希望尽可能增加这个结构的复杂度。

    T(m)=2\cdot O(m)+T\left(\frac{m}{2}\right)

    $$

解得 $T(m)=O(m)$ .

    解得 $T(m)=O(m)$ 。

于是，总复杂度仍是 $O(mp)$ .

    于是，总复杂度仍是 $O(mp)$ 。

### 询问操作

    ---

    在询问的时侯，我们要处理的应该是“在两个栈中选若干个元素的最大价值”的问题。因此要对栈顶的 DP 值做查询，即两个 $f,g$ 对于询问[l,r]的最大价值：

    \max_{0\leq i<p}\left\{f[i]+\max_{l\leq i+j\leq r}g_j\right\}

    $$

这个问题暴力做是 $O(p^2)$ 的，不过一个妥妥的单调队列可以做到 $O(p)$ .

    这个问题暴力做是 $O(p^2)$ 的，不过一个妥妥的单调队列可以做到 $O(p)$ 。

??? note "参考代码"

    ```cpp

    #include <algorithm>

    #include <cctype>

    /******************heading******************/

    const int M = 5e4 + 5, P = 505;

    int I, m, p;

    ```

    inline int _(int d) { return (d + p) % p; }

    namespace DQ {       // 双栈模拟双端队列

若 $G$ 为无向图，则 $E$ 中的每个元素为一个无序二元组 $(u, v)$ ，称作 **无向边 (Undirected edge)** ，简称 **边 (Edge)** ，其中 $u, v \in V$ 。设 $e = (u, v)$ ，则 $u$ 和 $v$ 称为 $e$ 的 **端点 (Endpoint)** 。

若 $G$ 为有向图，则 $E$ 中的每一个元素为一个有序二元组 $(u, v)$ ，有时也写作 $u \to v$ ，称作 **有向边 (Directed edge)** 或 **弧 (Arc)** ，在不引起混淆的情况下也可以称作 **边 (Edge)** 。设 $e = u \to v$ ，则此时 $u$ 称为 $e$ 的 **起点 (Tail)** ， $v$ 称为 $e$ 的 **终点 (Head)** ，起点和终点也称为 $e$ 的 **端点 (Endpoint)** 。并称 $u$ 是 $v$ 的直接前驱， $v$ 是 $v$ 的直接后继。

若 $G$ 为有向图，则 $E$ 中的每一个元素为一个有序二元组 $(u, v)$ ，有时也写作 $u \to v$ ，称作 **有向边 (Directed edge)** 或 **弧 (Arc)** ，在不引起混淆的情况下也可以称作 **边 (Edge)** 。设 $e = u \to v$ ，则此时 $u$ 称为 $e$ 的 **起点 (Tail)** ， $v$ 称为 $e$ 的 **终点 (Head)** ，起点和终点也称为 $e$ 的 **端点 (Endpoint)** 。并称 $u$ 是 $v$ 的直接前驱， $v$ 是 $u$ 的直接后继。

???+note "为什么起点是 Tail，终点是 Head？"

    边通常用箭头表示，而箭头是从“尾”指向“头”的。