P5999 [CEOI2016] kangaroo 题解

感觉这样的 $\text{dp}$ 题还比较多，思路都比较的神奇。

个人感觉比较像区间 $\text{dp}$ 的一类变种。

但又和区间 $\text{dp}$ 的维护方式极不一样。

对于此类 $\text{dp}$#

这一类 $\text{dp}$ 主要维护的是一个一个的块，可以理解成连通块。

将 $f_{i,j}$ 看作放置 $\text{i}$ 个元素，形成了 $\text{j}$ 个块的方案数。

有三类操作。

1. 将某个块的元素个数加一#

那么每一个块都有可能加一。

所以。

$$f_{i,j}=f_{i-1,j}\times j$$

2. 新增一个块#

类似插空的思路。

原来有 $j-1$ 个块，所以有 $\text{j}$ 个空。

$$f_{i,j}=f_{i-1,j-1}\times j$$

3. 合并两个块#

与第二点类似，但是不能在两边插空。

所以还是只有 $\text{j}$ 个空。

$$f_{i,j}=f_{i-1,j+1}\times j$$

时间复杂度 $O(n^2)$。

这就是这一类问题的基本操作。

关于本题#

我们发现，对于一般的 $\text{dp}$ 而言，不怎么好去维护这个问题。

就可以考虑一下上面所说的 $\text{dp}$。

我们从小到大去给元素排位置。

还是从三种情况去讨论。

1. 新增元素

可以发现，对于一个新增加的元素，他的前面必然是比他小的，而后面必然会加一个更大的，所以没有这种情况。

2. 新增块

这种情况肯定是可以的，因为前后都没有元素。

3. 合并块

可以发现，合并两个块是，周围的两个元素一定都比新加入的元素小，所以都可以。

4. 一个细节

此题有 $\text{s,t}$ 的限制，这个不是很难，直接判一下就可以了。

代码实现还是比较简单的。

Code#

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 2010;
const int mod = 1e9 + 7;

int n , s , t , f[N][N];

inline int read()
{
    int asd = 0 , qwe = 1; char zxc;
    while(!isdigit(zxc = getchar())) if(zxc == '-') qwe = -1;
    while(isdigit(zxc)) asd = asd * 10 + zxc - '0' , zxc = getchar();
    return asd * qwe;
}

signed main()
{
    f[1][1] = 1;
    n = read() , s = read() , t = read();
    for(int i = 2;i <= n;i++)
    {
        for(int j = 1;j <= n;j++)
        {
            if(i == s || i == t)
            {
                f[i][j] += f[i - 1][j - 1] + f[i - 1][j];
                f[i][j] %= mod;
                continue;
            }
            int res = (i > s) + (i > t);
            f[i][j] += f[i - 1][j - 1] * (j - res);
            f[i][j] += f[i - 1][j + 1] * j;
            f[i][j] %= mod;
        }
    }
    cout << f[n][1] << endl;
    return 0;
}