栈

题目背景
栈是计算机中经典的数据结构，简单的说，栈就是限制在一端进行插入删除操作的线性表。

栈有两种最重要的操作，即 pop（从栈顶弹出一个元素）和 push（将一个元素进栈）。

栈的重要性不言自明，任何一门数据结构的课程都会介绍栈。宁宁同学在复习栈的基本概念时，想到了一个书上没有讲过的问题，而他自己无法给出答案，所以需要你的帮忙。

题目描述

宁宁考虑的是这样一个问题：一个操作数序列，1,2,\ldots ,n1,2,…,n（图示为 1 到 3 的情况），栈 A 的深度大于 nn。

现在可以进行两种操作，

将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的 push 操作）
将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的 pop 操作）
使用这两种操作，由一个操作数序列就可以得到一系列的输出序列，下图所示为由 1 2 3 生成序列 2 3 1 的过程。

（原始状态如上图所示）

你的程序将对给定的 nn，计算并输出由操作数序列 1,2,\ldots,n1,2,…,n 经过操作可能得到的输出序列的总数。

输入格式
输入文件只含一个整数 nn（1 \leq n \leq 181≤n≤18）。

输出格式
输出文件只有一行，即可能输出序列的总数目。

输入输出样例
输入 #1
3
输出 #1
5

> 这道题可以用dfs，不过会超时一个点。所以用带备忘录的dfs就好了。也可以用dp做也可以，不过过程可能比dfs要难那么一点点，还可以用卡特兰来做（这里介绍这三种方法，我只会这三种（逃）。
*先来看看卡特兰吧，看到题目可以给出了。定义 f[i]表示i个数的所有可能性，f[0]=1,f[1]=1,假设X为最后一个出栈的元素，那么在这之前有n-X个元素比X大，有X-1个元素比X小，这两部分又相互影响，所以最后一个元素出栈为X的全部可能性是f[n-X]f[X-1],X的取值为1—n都有可能，所以X为1—n的所有情况相加即可：
f(n)=f(0)*f(n-1)+f(1)*f(n-2)+f(2)*f(n-3)+f(3)*f(n-4)+…f(n-1)*f(0)

这就是卡特兰，有了这个代码就很好写了，递推即可

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

int ktl(int n);//卡特兰


    int main()
    {
      
        int n;
        cin>>n;
        cout<<ktl(n);
        return 0;
    }



 
    int ktl(int n) //卡特兰
    {
        int t[30];
        memset(t,0, sizeof(t));
        t[1]=t[0]=1;
        //t[2]=t[0]*t[1]+t[1]*t[0]
        //t[3]=t[0]*t[2]+t[1]*t[1]+t[2]*t[0]
        //t[4]=t[0]*t[3]+t[1]*t[2]+t[2]*t[1]+t[3]*t[0]

        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<i;j++) //递推计算出每一t[i]  因为计算t[i+1]需要用到t[i]
            {
                t[i]=t[i]+t[j]*t[i-j-1];
            }
        }
        return t[n];
    }
    

**再来看一下dfs 用f[i][j]表示栈里面有i个元素，队列里面有j个元素时的所有可能情况数，即f[0][30]
就是我们要求解的值。
如果队列为空，那么直接return 1;因为此时只能从栈里面将元素顺序弹出。
如果队列不为空，那么，如果此时栈为空：即:
f[i][j]=f[i+1][j-1] //即栈里面加一个元素，队列减去一个元素
如果栈为空：f[i][j]=f[i-1][j]+f[i+1][j-1] //即栈弹出一个元素，或者队列弹一个元素进栈
注意：这道题纯dfs会wa一个点，所以建一个备忘录数组

#include <iostream>
#include <cstring>
using namespace std;
int f(int i,int j);//dfs

    int main()
    {
        memset(memory,0,sizeof(memory));
        int n;
        cin>>n;
        cout<<f(0,n);
        return 0;
    }



    int f(int i,int j) //dfs
    {

        if(j==0) //如果对列为空
        {
            return 1;
        }
        if(memory[i][j]!=0)
        {
            return memory[i][j];
        }
        if(i==0)
        {
            return memory[i][j]=f(i+1,j-1);
        }
        if(i!=0)
        {
            return memory[i][j]=f(i+1,j-1)+f(i-1,j);
        }
    }

第三个就轮到我们的大哥dp登场了，有了刚才dfs的推导，dp理解起来会简单很多。
设置 dp[i][j]为当栈里面有i个元素，队列里面有j个元素时的所有情况，即dp[0][n]就是我们要求得值
那么显然可以得到当j==0时 dp[i][j]=1 当i==0时，dp[i][j]=dp[i+1][j-1]//此时栈内为空，必须从队列中取出一个元素入栈，当i!=0时dp[i][j]=dp[i-1][j]+dp[i+1][j-1]//从栈顶弹出一个元素或者入栈一个元素，这个就是动态转移方程 他的边界就是当j=0时dp[i][j]==1

怎么合理的取递推也是动态转移方程能否求出的核心，可以这样试一下，首先初始化dp[1][0]=1,dp[2][0]=1,dp[3][0]=1…dp[n][0]=1,然后再去想办法递推，当j不变时 ,i从0-- 递增至n的结果如下：

dp[0][1]=dp[1][0],dp[0][2]=dp[1][1]//但是此时dp[1][1]并没有求出，根据方程式dp[i][j]=dp[i-1][j]+dp[i+1][j-1]可知dp[i+1][j]=dp[i][j]+dp[i+2][j-1]，故换一种方式来递推，j固定时，i从0递增至n，代码如下：

#include <iostream>
#include <cstring>
using namespace std;
int dy(int n);
    int main()
    {

        int n;
        cin>>n;
        //cout<<f(0,n);
        //cout<<ktl(n);
        cout<<dy(n);
        return 0;
    }



    int dy(int n)
    {
        int dp[20][20];
        memset(dp,0, sizeof(dp));
        for(int i=0;i<=20;i++)
        {
            dp[i][0]=1;//队列元素个数为0的时候就是1
        }
        for(int j=1;j<=n;j++)
        {
            for(int i=0;i<=n;i++)
            {
                if(i==0)
                {
                    dp[i][j]=dp[i+1][j-1];
                } else
                {
                    dp[i][j]=dp[i+1][j-1]+dp[i-1][j];
                }
                if(j==n)
                {
                    break;
                }
            }
        }
        return dp[0][n];
    }