学大伟业 Day 5 培训总结

今天讲数据结构

先从mzx大佬的ppt摘抄一段：

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。

通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。（摘自百度百科）

简单来说，我们可以把数据的集合视为一个数组，即数组的元素就是我们所存储的数据，

同时，我们再用一系列指针（在OI中一般不用指针而用下标来代替）维护这些数据之间的关系，使得我们能够更方便地管理我们所需要用到的数据。

数据结构很多时候是用来优化算法的，所以我们需要搞清楚我们算法需要对数据进行什么样的操作，根据需求来选择所需要的数据结构。

在学习一个数据结构时，你应该按这样的先后顺序来记忆： 1.作用（支持的操作）及复杂度 2.原理（代码实现） 3.正确性/复杂度证明

数据结构存储的是数据，它们可以是整数(int/long long)，实数(float/double)，也可以是我们自己定义的结构体。

目录：

 

栈

队列

堆（优先队列）

分块

线段树

树状数组

 

一.栈

 

栈是一种先进后出（FILO，即first-in-last-out）的数据结构，你可以把它想象成一个只开一个口的乒乓球筒，每次只能从最顶端处放置或取出数据。

一般在OI中我们用一个数组和栈顶指针（用int表示的下标）来模拟一个栈。

栈支持两个操作：1.向栈顶加入一个元素 2.从栈顶取出一个元素 这两个操作的时间复杂度都是O(1)。

那么它所维护的这个数据集合中，数据之间有什么样的关系呢？

很简单，就是fisrt-in-last-out，或者更具体一点：如果一个元素在另一个元素之前加入这个集合中，那么它一定在那个元素之后退出这个集合。（摘自mzx大佬的ppt）

看一道例题：

火车进站

有一个车站，每天都会有N辆车进站，进站按从1到N的顺序进站。

现在车站的站长想让这些火车按照特定的顺序出站，问可以做到吗？

当N为5时，出站顺序若为1 2 3 4 5，可以做到，但是顺序若为5 4 1 2 3，则不行。

直接用栈模拟：

#include<iostream>
#include<cstdio>
using namespace std;
int n,a[101],s[101],now,top;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    now=1;
    for(int i=1;i<=n;i++)
    {
        top++;
        s[top]=i;
           while((s[top]==a[now])&&(top>0)&&(now>0))
        {                                         
            top--;
            now++;
        }
    }
    if(top!=0)
    printf("NO");
    else
    printf("YES");
    return 0;
}

值得注意的是此题时间复杂度需要用均摊分析：

第二层循环一共执行n次，最坏一次n次，均摊后复杂度为O(1),总复杂度为O(n)。by——cym大佬的笔记（其实还是mzx讲的）

单调栈：

 

单调栈只是栈的一个特殊用法而已，本质上依然是一个栈。

单调栈要求栈中的元素从栈底到栈顶是单调（有序）的，所以在加入一个新的元素时，如果它和栈顶元素不满足单调，那么将会依次弹出栈顶的元素直到这个元素加入到栈中依然满足单调，才

将这个元素加入到栈中。

 

队列：

 

队列是一种先进先出（FIFO，即first-in-fisrt-out）的数据结构，你可以把它想象成一个羽毛球筒，每次只能从尾部添加元素，从头部取出元素，除非你想把你的羽毛球弄坏。

一般在OI中我们用一个数组和队头和队尾指针（用int表示的下标）来模拟一个队列。

队列支持两个操作：1.向队尾加入一个元素 2.从队头取出一个元素 这两个操作的时间复杂度都是O(1)。

那么它所维护的这个数据集合中，数据之间有什么样的关系呢？ 很简单，就是fisrt-in-first-out，或者更具体一点：如果一个元素在另一个元素之前加入这个集合中，那么它一定在那个元素之前

退出这个集合。

 

上面两个没例题是因为我懒...有时间会补的（胡说八道）

 

其实我更关心的是这个：

单调队列！

 

单调队列只是队列的一个特殊用法而已，本质上依然是一个队列。

单调队列要求队列中的元素从队头到队尾是单调（有序）的，所以在加入一个新的元素时，如果它和队尾元素不满足单调，那么将会依次弹出栈顶的元素直到这个元素加入到队尾依然满足单

调，才将这个元素加入到队列中。

需要注意的是，这个插入到队尾的操作和单调栈比较相似，甚至可以说一样，不同的是取元素时的位置。

 

例题：

首先想到的就应该是：滑动窗口！

题目链接：https://www.luogu.org/problemnew/show/P1886

这道题是一道典型的单调队列

在这里引用luogu一位大佬hankeke对单调队列的讲解：

 

单调队列有两个性质

 

1. 队列中的元素其对应在原来的列表中的顺序必须是单调递增的。

2. 队列中元素的大小必须是单调递*(增/减/甚至是自定义也可以)

 

单调队列与普通队列不一样的地方就在于单调队列既可以从队首出队，也可以从队尾出队。

 

那么我们应该怎样实现单调队列呢?

 

就拿样例来谈谈，设以最小的为标准。

 

8 3
1 3 -1 -3 5 3 6 7

 

下文中我们用q来表示单调队列，p来表示其所对应的在原列表里的序号。

 

1. 由于此时队中没有一个元素，我们直接令1进队。此时，q={1},p={1}。

2. 现在3面临着抉择。下面基于这样一个思想:假如把3放进去，如果后面2个数都比它大，那么3在其有生之年就有可能成为最小的。此时，q={1,3},p={1,2}

3. 下面出现了-1。队尾元素3比-1大，那么意味着只要-1进队，那么3在其有生之年必定成为不了最小值，原因很明显:因为当下面3被框起来，那么-1也一定被框起来，所以3永远不能当最小值。所以，3从队尾出队。同理，1从队尾出队。最后-1进队，此时q={-1},p={3}

4. 出现-3，同上面分析，-1>-3，-1从队尾出队,-3从队尾进队。q={-3}，p={4}。

5. 出现5，因为5>-3，同第二条分析，5在有生之年还是有希望的，所以5进队。此时，q={-3,5},p={4,5}

6. 出现3。3先与队尾的5比较，3<5，按照第3条的分析，5从队尾出队。3再与-3比较，同第二条分析，3进队。此时，q={-3,3},p={4,6}

7. 出现6。6与3比较，因为3<6，所以3不必出队。由于3以前元素都＜3，所以不必再比较，6进队。因为-3此时已经在滑动窗口之外，所以-3从队首出队。此时，q={3,6},p={6,7}

8. 出现7。队尾元素6小于7，7进队。此时，q={3,6,7},p={6,7,8}。

 

那么，我们对单调队列的基本操作已经分析完毕。因为单调队列中元素大小单调递*(增/减/自定义比较)，因此，队首元素必定是最值。按题意输出即可。

代码如下：

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 2000000 + 10;
int a[maxn], que[maxn], ppp[maxn], head, tail, k, n; 
int min_queue()
{
    head = 1; tail = 0;
    for(int i = 1; i <= n-1; i++)
    {
        
        while(head<=tail && que[tail]>=a[i]) tail--;
        que[++tail] = a[i];
        ppp[tail] = i;
        while(ppp[head]<=i-k)
            head++;
        if(i>=k) printf("%d\n",que[head]);
    }
    printf("\n");
}
int max_queue()
{
    head = 1; tail = 0;
    for(int i = 1; i <= n; i++)
    {
        while(head<=tail && que[tail]<=a[i]) tail--;
        que[++tail] = a[i];
        ppp[tail] = i;
        while(ppp[head]<=i-k)
            head++;
        if(i>=k) printf("%d ",que[head]);
    }
}
int main()
{
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i++)
    scanf("%d",&a[i]);
    //printf("0\n");
    min_queue();
    max_queue();
    return 0;
}

 

 

还有一道是luogu的P1440

这道题看到是让查询区间的最值，果断想到用ST表头铁一波，然后T了两个点（当然有的大佬会用ST表优化过掉...然而我不会...）

 

//ST表头铁80分 
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 2000000 + 1;
int st[maxn][21], ans[maxn];
int j, i, left, right, n, m, a;
int main()
{
    scanf("%d%d",&n, &m);
    for(i = 1; i <= n; i++)
    {
        scanf("%d",&a);
        st[i][0] = a;
    }
    
    for(j = 1; (1<<j) <= n; j++)
        for(i = 1; i <= n-(1<<j)+1; i++)
        st[i][j] = min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
    
    for(i = 1; i <= n-m+1; i++)
    {
        j = 0;
        left = i;
        right = left + m - 1;
        
        while((1<<(j+1)) <= (right-left+1)) j++;
        ans[i] = min(st[left][j],st[right-(1<<j)+1][j]);
        
    }
    printf("0\n");
    for(int i=1;i<=m-1;i++)
    {
        left = 1;
        right = i;
        j = 0;
        while((1<<(j+1)) <= (right-left+1)) j++;
        printf("%d\n",min(st[left][j],st[right-(1<<j)+1][j]));
    }
    for(i = 1; i <= n-m; i++)
    printf("%d\n",ans[i]);
}
//前m-1个数 ，第一个一定是0 

 

当然正解就是我们要用到的单调队列啦

 其实把滑动窗口的改一改就好...

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 2000000 + 10;
int a[maxn], que[maxn], ppp[maxn], head, tail, k, n; 
int min_queue()
{
    head = 1; tail = 0;
    for(int i = 1; i <= n-1; i++)
    {
        
        while(head<=tail && que[tail]>=a[i]) tail--;
        que[++tail] = a[i];
        ppp[tail] = i;
        while(ppp[head]<=i-k)
            head++;
        /*if(i>=k)*/ printf("%d\n",que[head]);
    }
    printf("\n");
}
/*int max_queue()
{
    head = 1; tail = 0;
    for(int i = 1; i <= n; i++)
    {
        while(head<=tail && que[tail]<=a[i]) tail--;
        que[++tail] = a[i];
        ppp[tail] = i;
        while(ppp[head]<=i-k)
            head++;
        if(i>=k) printf("%d ",que[head]);
    }
}*/
int main()
{
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i++)
    scanf("%d",&a[i]);
    printf("0\n");
    min_queue();
    max_queue();
    return 0;
}

优先队列

“优先队列”这个概念包括了很多数据结构，我们把具有以下功能的数据结构统称为“优先队列”，或者说这些数据结构是“优先队列”的不同实现方式：

1.将一个元素插入到集合中

2.取出集合中最小/最大的元素 支持以上操作的数据结构有二叉堆/斜堆/二项堆/斐波那契堆等，这两个操作的时间复杂度一般为O(logn)（n为集合大小），当然，它们同时也支持很多其他操作，

比如修改元素的大小或者合并两个堆（支持这个操作的堆也叫可并堆）等，通过名字可以看到，优先队列一般也被称为“堆”。

但是，对于C++选手来说，stl内置了一个叫priority_queue（翻译即为优先队列）的数据结构，它支持插入，查询或删除最大值的操作，所以，我们一般只需要直接使用它而不需要自己手动实现

一个二叉堆（除非你需要支持其他的操作）。

在本博客里有STL堆模板了，这里不再放。

例题：合并果子

题目链接：https://www.luogu.org/problemnew/show/P1090#sub

思路：每次取出最小的两堆，合并完再入堆，直到堆里面没有元素。