P1044 [NOIP2003 普及组] 栈

P1044 [NOIP2003 普及组] 栈

题目背景

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

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

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

题目描述

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

现在可以进行两种操作，

1. 将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的 push 操作）
2. 将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的 pop 操作）

使用这两种操作，由一个操作数序列就可以得到一系列的输出序列，下图所示为由 1 2 3 生成序列 2 3 1 的过程。

（原始状态如上图所示）

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

输入格式

输入文件只含一个整数 $n$（$1\le n\le 18$）。

输出格式

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

样例 #1

样例输入 #1

3

样例输出 #1

5

提示

【题目来源】

NOIP 2003 普及组第三题

1、递归/记忆化搜索

看这个数据，我总感觉dfs会超时，然后真的超了？（没试过），于是很自然的，我们就会想到记忆化搜索，这也是做这题的一种技巧吧，但无论如何，这也是最基础的

解题思路

递归归根到底就是两点 递归边界 和 递归规则。递归的好处也在此，只需要考虑递归的关系和边界，中间一系列复杂的操作就不用顾忌 。下面谈谈搜索(递归)思路，其中 1为递归的关系式含义；2、3为递归边界；4为递归规则：

1. 既然记忆化搜索了，定义一个二维数组$f[i,j]$
   • 用下标 $i$ 表示队列里还有几个待排的数，
   • $j$ 表示栈里有 $j$ 个数，
   • $f[i,j]$ 表示此时的情况数
2. 那么，更加自然的，只要$f[i,j]$有值就直接返回；
3. 然后递归如何实现呢？首先，可以想到，要是数全在栈里了，就只剩$1$种情况了，所以：$i=0$ 时，返回$1$；
4. 然后，有两种情况：一种栈空，一种栈不空。
   • 在栈空时，我们不可以弹出栈里的元素，只能进入，所以队列里的数$-1$，栈里的数$+1$，即加上 $f[i-1,j+1]$；
   • 另一种是栈不空，那么此时有出栈$1$个或者进$1$个再出$1$个 $2$种情况，分别加上 $f[i-1,j+1]$和 $f[i,j-1]$ ，便是此时的情况了，于是递归就愉快的结束了；

代码实现

#include<cstdio>
#define MAX_N 20
#define ll long long
using namespace std;
int n;
ll f[MAX_N][MAX_N];
ll dfs(int i,int j)
{
//   if f[i][j]>0
	if(f[i][j]) return f[i][j]; 
	if(i==0)return 1; //边界 
	if(j>0) f[i][j]+=dfs(i,j-1);
	f[i][j]+=dfs(i-1,j+1);
	return f[i][j];
}
int main()
{
	scanf("%d",&n);
	printf("%lld",dfs(n,0));
	return 0;
}

2、递推$DP$(动态规划)

我们只要顺着递归的思路来就好了：

1. 据上面的递归，可知定义的 $f[i,j]$ 中 $i=0$ 时这个数组的值都为$1$，同时，这也是递推边界。并且，我们用 $i$ 表示已经进到过栈里的数（只要进过栈的都加上），$j$ 表示出栈数，$f[i,j]$ 表示情况数；
2. 既然我们愉快地得到了递推思路，愣着干嘛，因为即使初始化了我们也不可能直接用递归的思路写出递归！所以开始找规律：$f[i,j]$到底与什么有着不可告人的联系？其实这个很容易可以想到：当 $i$ 个数进栈，$j-1$ 个数出栈的时候，只要再出一个数，便是 $i$ 个数进栈，$j$ 个数出栈的情况；同理，对于进栈 $i-1$ 个数，出栈 $j$ 个数，在进栈一个数便是 $f[i,j]$ 了，于是就有了递归式：$f[i,j]=f[i][j-1]+f[i-1][j]$.
3. 然而事实上这还没有完，因为 $i=j$ 时，很明显的 栈空了，那么，此时就必须进栈了，则有 $f[i,j]=f[i-1,j]$ 。

于是我们又快乐地解决了递推(其实就是$DP$)的做法，其实与递归大同小异，只不过一个通过函数实现，一个通过循环实现。

#include<cstdio>
#define MAX_N 20
#define ll long long
using namespace std;
int n;
ll f[MAX_N][MAX_N];
int main()
{
	scanf("%d",&n);
	for(int i=0;i<=n;i++)
	{
		f[0][i]=1;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=i;j<=n;j++)
		{
			if(i==j)f[i][j]=f[i-1][j];
			else f[i][j]=f[i][j-1]+f[i-1][j];
		}
	}
	printf("%lld",f[n][n]);
	return 0;
}

3、数论做法 卡特兰/Catalan

建立数组 $f$ 。$f[i]$ 表示 $i$ 个数的全部可能性。

• $f[0]=1$, $f[1]=1$，当然只有一个

• 设 $x$ 为当前出栈序列的最后一个，则 $x$ 有 $n$ 种取值。由于x是最后一个出栈的，所以可以将已经出栈的数分成两部分：

  1. 比 $x$ 小，比 $x$ 小的数有 $x-1$ 个，所以这些数的全部出栈可能为 $f[x-1]$
  2. 比 $x$ 大，比 $x$ 大的数有 $n-x$ 个，所以这些数的全部出栈可能为 $f[n-x]$
  3. 这两部分互相影响，所以一个 $x$ 的取值能够得到的所有可能性为 $f[x-1]\ast f[n-x]$

• 另外，由于 $x$ 有 $n$ 个取值，所以 $ans=f[0]\ast f[n-1]+f[1]\ast f[n-2]+...+f[n-1]\ast f[0]$

这，就是传说中的卡特兰数，下面给出卡特兰数的递推式：

• 递推式1： $f[n]=f[0]\ast f[n-1]+f[1]\ast f[n-2]+...+f[n-1]\ast f[0](n\ge 2)$

//数论做法 卡特兰数
//公式1：
#include<cstdio>
#define MAX_N 20
#define ll long long
using namespace std;
int n;
ll f[MAX_N];
int main()
{
	f[0]=f[1]=1;
	scanf("%d",&n);
	for(int i=2;i<=n;i++)
	{
		for(int j=0;j<i;j++)
		{
			f[i]+=f[j]*f[i-j-1];
		}
	}
	printf("%lld",f[n]);
	return 0;
}

• 递推式2： $h[n]=h[n-1]\ast (4\ast n-2)/(n+1)$

//公式2：
#include<cstdio>
#define MAX_N 20
#define ll long long
using namespace std;
int n;
ll f[MAX_N];
int main()
{
	f[0]=f[1]=1;
	scanf("%d",&n);
	for(int i=2;i<=n;i++)
	{
		f[i]+=f[i-1]*(4*i-2)/(i+1);
	}
	printf("%lld",f[n]);
	return 0;
}

• 递推式3： $h[n]=C[2n,n]/(n+1)(n=0,1,2,...)$，$C$ 是组合数
  • $PS$ ：$C[m,n]=C[m-1,n-1]+C[m-1,n]$，
  • 且规定： $C[n,0]=1$ ， $C[n,n]=1$ ， $C[0,0]=1$
  • 这个公式也叫组合数公式(下面那个也是)（不知道组合数可以百度）

//公式3：
#include<cstdio>
#define MAX_N 20
#define ll long long
using namespace std;
int n;
ll c[MAX_N*2][MAX_N];
int main(){

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

• 递推式4： $h[n]=C[2n,n]-C[2n,n-1](n=0,1,2,...)$ ，组合数 $C$ 不解释了；

//公式4： 
#include<cstdio>
#define MAX_N 20
#define ll long long
using namespace std;
int n;
ll c[MAX_N*2][MAX_N];
int main(){

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

但是有个Dalao写的组合数我没看懂，于是我搜集了各方资料，还是没看懂，不知道他写的组合数是怎么求的，虽然最后结果对了，但是组合数求出来都是错的(￣_￣|||)，不知道是不是巧合？

不管了，AC就好；（程序还是后面给~）

• 但是，出现了一个问题，上面介绍了四种公式，哪种最好？其实是第 $4$ 种：如果这个数太大，那么题目可能会要求取模，那么第 $1$ 种 $n$ 太大的时候时空太大；第 $2$ 种在取模运算中万一不小心整除了就凉了；第 $3$ 种是除法运算，更行不通；唯有第 $4$ 种，满足取模原则（加减无所谓），且不会出现倍数 WA的情况，所以第 $4$ 种解为最优解；
• 接着，比较上面四种做法：很明显的，递推式长得差得不多，它们都源于卡特兰思想，那么就没什么好说的了，只是时空复杂度的不同而已；

总之，个人感觉还是前两种解法吧，本人最后一个数学功底真的不太行。