0x11

                                基本数据结构：栈

栈是什么？

       通俗一点：我们把栈比作一个桶。。。

       就是这个了      ->_->    我们每次可以往栈里放东西，然后就变这样子了。~>__~>

       我们是一个一个放进去的呀。。。所以理所应当要从上往下面一个一个取出来。。。

       其实DFS用的递归也是栈。。。

       它是FILO（first in last out）=》先进后出。。。

栈的基本操作？

       emmmm。。。。常用的栈操作有   push   pop   top  别忘了头文件<stack>  

      申请栈法则：  stack<类型名>  q

     push:把元素放进栈里。。。例子：q.push(x)

     pop：把栈顶的元素删除。。。例子：q.pop（）

     top:取栈顶的元素。。。例子：x=q.top()

---------------------------------------------------------------------------------------------------- 

       一般为了保险。。。我们都是手写栈的。。。

      int Stack[max_n] ,index=0;

      Stack[index++]=x等同于push

      index--等同于pop

      x=Stack[index-1]等同于top

     PS：注意元素类型不同，申请的栈数组类型也要不同啊。。。

-----------------------------------------------------------------------------------------------------

栈的应用？

例题：实现一个栈支持push（入栈）,pop（出栈并输出栈顶）,getmin（查询栈中最小值），要求时间复杂度为O（1）

首先O（1）的push，pop是本身就有的。。。唯一就是查询栈内的最小值。。。

尝试一：用一个变量记住最小值。

结果：失败。原因:假设最小值出栈了。。下一个又是谁呢。。。

尝试二：把栈内的数排序。

结果：看起来成功，但是失败。原因：题目要求O（1）这个是O（nlogn）的。。。

尝试三：两个栈。一个栈很正常，另一个栈存放每个时刻的最小值。。。

栈A: 9 2 1 5 3 0 2 

栈B: 9 2 1 1 1 0 0

我们发现最小值是单调的。。。所以就很好维护了。。。

例题Editor:题面传送门——>http://acm.hdu.edu.cn/showproblem.php?pid=4699

其实这个也很简单。。。

I操作就是入栈

D操作就是出栈

L和R就需要另一个栈了。。。为什么呢。。。因为一个栈的话你要向左移动光标也就是要把这个栈的栈顶去掉。。。

但是又不能丢掉，因为有R操作，你就找不到丢失的元素了。。所以我们要再开一个数据结构可以做到“FLIO”为什么要FLIO呢？

想象一下。。左移光标的时候把光标扫过的区域全丢到垃圾桶了，但是右移的时候，要把丢尽垃圾桶的元素找回来，而且要按原来的顺序排列。。那就是把元素一一丢尽垃圾桶的顺序反过来，也就是FLIO了。。。那也就只有栈能做到了吧。。。

我们把这种做法叫做对顶栈。。。

最后一个操作Q：。。。貌似是DP的思想f[i]表示1---i的最大的前缀和。。sum[i]表示i的前缀和。。易得sum[i]=sum[i-1]+当前元素。。f[i]=max(f[i-1],sum[i])然后每次操作维护一下栈顶就行了。。。PS：这里就需要手写栈了。。。这样会方便很多。。。

例题：进出栈序列问题  ->__->https://www.luogu.org/problemnew/show/P1044

     方法一：暴力无限好

     模拟进出栈：O（2^n）

     当前状态，要么进栈，要么出栈。爆搜一下就行了。。。

     方法二：Catalan数。。。。证明一下吧;

     首先。我们并不是很关心，那个数到底是什么。我们只需要知道他有多少种不同的顺序就行了。。。

     也就不用那么暴力去模拟了。。。

      1----n个数，如果最后一个出栈的是x

      那么1----x在x入栈之前一定都会出栈。。

      接着就是x入栈后，x+1-----n都会出栈。。。

      如果我们知道x-1个数出栈的顺序有多少种，，以及n-x个数出栈的顺序有多少种。。。

      就知道x作为最后出栈的元素的顺序有多少种。。。乘法原理。。。f[i]表示i个数出栈的顺序有多少种。

      所以就是f[x-1]*f[n-x]了。。。如果我们要知道f[n]就要枚举1-----n个元素分别最后一个出队。。。。

      那么f[0]----f[n-1]的都要算出来。。。所以我们就找到了一种DP的顺序从0----n仔细观察就会发现其实这就是Catalan了。。。

      其实，一开始我也不知道它就是Catalan，只是经过推导，刚好发现而已。。。

#include <iostream>
#include <cstdio>
using namespace std;

int n, f[30];

int main()
{
    scanf("%d", &n);
    f[0] = 1;
    f[1] = 1;
    for(int i=2; i<=n; i++)              
        for(int j=0; j<i; j++) 
            f[i] += f[j] * f[i-j-1];
    printf("%d", f[n]);
    return 0;
}

拓展：单调栈（强大的工具）

       虽然它没有单调队列有名，但是也很强。。。

       例题：http://poj.org/problem?id=2559

       大意：给你一堆挨在一起的矩形，高低不同，求里面可以划分出来的一个面积最大的矩形。。。。

       复述李煜东大佬的话（虽然我懂了）：如果每个矩形的高度是递增的

分别计算这四个矩形的面积去一个最大值就行了。。。但是如果有一个下降的呢。。。

我们就会发现，在前面的计算里，我们已经算过了目前的最大值后面即使有更高的。那这一部分就是没有意义的了。。。所以我们可以把他们扔掉，然后用一个w存放之间的宽度。。。这样看来，我们维护的就是一个单调上升的一堆矩形。。但是我们每次从上一个删除到上上个。。所以就是栈了。。。单调栈。。。对吧。。。很强。。。。我看第一眼就这么觉得。。。。

一放代码就秒懂：(LYD的代码，我太蒟蒻了，写不出来这么强的东西)

a[n+1]=p=0;
for(int i=1;i<=n+1;i++)
{
    if(a[i]>s[p])
        s[++p]=a[i],w[p]=1;

    else
    {
        int width=0;
        while(s[p]>a[i])
        {
           width+=w[p];
           ans=max(ans,(long long)width*s[p]);
           p--;    
        }
        s[++p]=a[i],w[p]=width+1;  
    }
}