BZOJ4664 Count (思维题+计数DP)

题目描述

4664: Count

Description

小叶子的桌面上有 n 本高度不相同的书，n+e 现在需要把这些书按照一定的顺序摆放好。假设第 i 本书的高度为

 h[i]，n+e 的摆放用一个 1~n的排列 pi 来表示。定义一个摆放的混乱程度：|h[p2]-h[p1]|+|h[p3]-h[p2]|+…

…+|h[pn]-h[pn-1]|，即相邻两本书的高度差的绝对值之和。已知合法的摆放要求其混乱程度不超过 L。小叶子想

要知道，n+e 到底有多少种合法的摆放的方法呢？作为将要参加 NOI 的选手，你应该知道，小叶子只关心这个数

对10^9+7 取模的结果。

 

Input

第一行两个数 n,L。接下来一行 n 个数 h[i]

1<=n<=100,1<=L,h[i]<=1000

Output

输出一行，表示方案数对 10^9+7 取模的结果。

 

Sample Input

3 2
2 3 4

Sample Output

2
【样例解释】
两种合法的摆放姿势如下：
2 3 4
4 3 2

 

 

 

 

题解

首先有一个思路：把h值从小到大排序，依次插入序列中。

然后观察一下混乱度的性质，有了一个神奇的想法：

当a<b<c时，如果c插在了ab之间，那么我们可以先统计b-a之后，把a的值"拔高"变成b，再统计两次c-b。

比如说1 6 4的混乱度，可以在我们插入4的时候先加上4-1的答案，在把1"拔高"成4，再加上2*(6-4)

这样我们就可以边插入，边计算混乱度了。

 

当我们插入一些数后，这些数在绝对位置上会形成一些坐标连续的块

但是由于有一些位置插入了数，有一些位置又没有数，所以我们直接维护块的绝对位置来DP是比较困难的

所以我们考虑维护这些块的相对位置

设f[i][j][k][l]表示已经插入了i个数，一共形成了j个块，其中有k(0~2)个块是紧贴边界的，它们的混乱度为l时的总方案数为f[i][j][k][l]

如图（其中j=3,k=1）：

想一想我们为什么可以只记录块的状态（如块的个数、是否在边界）来进行DP？

 

因为之前的“拔高”思想，我们在插入一个数之后，只需要将其他可能会与下一个数相邻的数拔高到当前数的高度即可

（注意，这里的相邻只是在当前插入i个数时的相邻，并不一定是最后状态的相邻）

（“拔高”思想其实就是在当前位置提前计算后面需要的混乱度，也就是当前的混乱度不一定是真正的当前混乱度，但是最后的混乱度一定是正确的）

而“可能会与下一个数相邻的数”只会是一个块两端的数，而位于边界的块只有一个这样的数，所以要用k特判

 

接下来就大力分类讨论（红色表示新插入的数）：

先来看三种情况

可以很轻松地用刷表法写出状态转移方程

1、f[i+1][j+1][k][tmp]+=f[i][j][k][l]*(j-k+1)     //新建一个块(谁都不贴)

2、f[i+1][j][k][tmp]+=f[i][j][k][l]*(2*j-k)      //贴在某一个的块(中间块+边界块)上

3、f[i+1][j+1][k+1][tmp]+=f[i][j][k][l]*(2-k)    //贴在边界上

此时tmp为新的混乱度，tmp=l+(h[i]-h[i-1])*(2*j-k)     ________其实2*j-k就是“可能会与下一个数相邻的数”的个数

 

再来看剩下的两种情况

4、f[i+1][j-1][k][tmp]+=f[i][j][k][l]*(j-1)     //合并两个块

5、f[i+1][j][k+1][tmp]+=f[i][j][k][l]*(2-k)     //合并块与边界

 

最后利用滚动数组优化一下，就可以啦

注意初始状态的处理

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int mod=1000000007;
int f[2][105][3][1005],h[105];
int main()
{
	int n,m,i,j,k,l;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++)
		scanf("%d",&h[i]);
	if(n==1){printf("1");return 0;}
	sort(h+1,h+n+1);
	if(h[n]-h[1]>m){printf("0");return 0;}
	int now;
	f[0][1][0][0]=1;
	f[0][1][1][0]=2;now=0;
	for(i=2;i<=n;i++){
		memset(f[now^1],0,sizeof(f[now^1]));
		for(j=1;j<=i;j++){
			for(k=0;k<=2;k++){
				for(l=0;l<=m;l++){
					//f[i][j][k][l]第i个数(滚动掉)，j个块(中间块+边界块)，k个边界块，l的混乱度下的方案数为f[i][j][k][l]
					int tmp=l+(h[i]-h[i-1])*(2*j-k);
					if(tmp>m) continue;
					int t=f[now][j][k][l];
					if(!t) continue;
					if(k<2){
						f[now^1][j+1][k+1][tmp]=(1ll*f[now^1][j+1][k+1][tmp]+1ll*t*(2-k)%mod)%mod;//贴在边界上
						f[now^1][j][k+1][tmp]=(1ll*f[now^1][j][k+1][tmp]+1ll*t*(2-k)%mod)%mod;//合并块与边界
					}
					f[now^1][j+1][k][tmp]=(1ll*f[now^1][j+1][k][tmp]+1ll*t*(j-k+1)%mod)%mod;//新建一个块(谁都不贴)
					f[now^1][j][k][tmp]=(1ll*f[now^1][j][k][tmp]+1ll*t*(2*j-k)%mod)%mod;//贴在已有的块(中间块+边界块)上
					f[now^1][j-1][k][tmp]=(1ll*f[now^1][j-1][k][tmp]+1ll*t*(j-1)%mod)%mod;//合并块(中间块)与块(中间块+边界块)
				}
			}
		}
		now^=1;
	}
	int ans=0;
	for(i=0;i<=m;i++)
		ans=(1ll*ans+1ll*f[now][1][2][i])%mod;
	printf("%d",ans);
}