[AHOI2009] BZOJ2431 逆序对数列-动态规划-前缀和优化

传送门

题目大意：求逆序对数为k的长为n的排列有多少？n,k<=1000

题解：这显然是个DP（废话）

而且dp
[k]表示长为n逆序对数为k的方案数。

而且状态转移显然要从dp[n-1][...]推过来。

考虑如果把n插入到1~(n-1)的某个逆序对数为x的排列的第p个数的后面，

那么会新产生(n-1)-(p+1)+1=n-p-1对新的逆序对，其中0<=p<=n-1是显然的。

因此如果当前状态dp
[k]，那么上一个状态就是dp[n-1][x=k-(n-p-1)=p+k+1-n]。

那么显然要求p+k+1-n>=0，因此p>=n-k-1，因此max(0,n-k-1)<=p<=n-1。

状态转移方程为：dp
[k]=sum{dp[n-1][p+k+1-n]},max(0,n-k-1)<=p<=n-1。

状态是O(n^2)的，转移是O(n)的，O(n^3)肯定要T。

优化其实是显然的，因为要求和，没有限制条件，还是连续区间，显然用前缀和优化。

具体来说，将max(0,n-k-1)<=p<=n-1代入到状态转移方程中“来源状态”的第二维，

可以得到dp
[k]对于dp[n-1][..]的求和区间是[max(0,n-k-1)+k+1-n,k]。

所以再用sumn
[k]表示sum{dp
[x]},0<=x<=k。

那么dp
[k]=sumn[n-1][k]-sumn[n-1][max(0,n-k-1)+k-n]。

这里实现有一个细节，就是第二个sumn的第二维有可能是-1，这个时候sumn=0，要特判一下。

另外一个细节是，对于每一个sumn
[比较大的...]，后面比较大的...也要算全了，即使后面的dp
[比较大的...]=0（不存在），因为状态转移需要。

这样转移的时间复杂度降到O(1)，总复杂度O(N^2)。

我的代码就写到这里了，又去看了看别人的做法，其实可以优化空间复杂度和编码复杂度（一会看看我的代码就知道我的代码有多乱和容易写错了）

空间复杂度O(N^2)看起来很不清真啊，首先由于dp
和sumn
都是由n-1转移来的，所以可以滚动数组优化到O(N)。

（注意并不是dp
[2]，而是dp
，可以滚动到真的只需要一维，具体实现留给大家思考）。

但编程还是要考虑上文提到的两个细节。注意到求和区间是非减的，所以可以用一个变量代替sumn数组，实现方式类似于可行性完全背包分组+单调队列的做法，编程复杂度特别低。而且不需要考虑上述两个细节。

代码：//BZOJ 2431
//AHOI 2009
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAXN 1010
#define mod 10000
using namespace std;
int dp[MAXN][MAXN],sumn[MAXN][MAXN];
int main()
{
int n,k;scanf("%d%d",&n,&k);
dp[1][0]=sumn[1][0]=sumn[1][1]=1;
for(int i=2;i<=n;i++)
{
dp[i][0]=sumn[i][0]=1;
for(int j=1;j<=min(k,i*(i-1)/2);j++)
{
int a=max(i-j-1,0),b;
if(j-i+a<0) b=0;
else b=sumn[i-1][j-i+a];
dp[i][j]=(sumn[i-1][j]-b)%mod;
sumn[i][j]=(sumn[i][j-1]+dp[i][j])%mod;
}
for(int j=min(k,i*(i-1)/2)+1;j<=min(k,i*(i+1)/2);j++)
sumn[i][j]=sumn[i][j-1];
}
dp
[k]=(dp
[k]+mod)%mod;
printf("%d\n",dp
[k]);return 0;
}