CF 1183H Subsequences dp

题意: 给出一个长度为n的字符串, 求一个大小为k的子序列集合, 使得花费最小, 每个子序列的花费是和原串的长度差.

思路:

其实只要知道, 这个字符串的各种花费的子序列有多少个, 先取花费小的(长的), 再取长度短的就好.

所以主要的问题就是求各个长度的子序列各有多少个.

注意到, 因为贡献只与子序列长度有关, 所以我们只关心长度和对应的个数, 具体字符串长什么样是无所谓的.

到此为止, 我们可以写出一个简单的递推式:

dp[i][j]表示前i位, 取得长度为j的子序列个数. dp[i][j]=dp[i-1][j-1](取当前这个字符加入子序列)+dp[i-1][j](不取当前这个字符加入子序列)

但这样做会重复计算一些情况: abcb的子序列中, ab会计算两次, 而在本题中是不允许的.

这个问题如何解决呢?

可以发现, 如果我们按上面的递推式计算, 重复的部分恰好是前面相同字符的前一个位置的长度为j-1的贡献.

换句话说, 这相当于第二个b又会和最前面的a结合一次. 为了去除这样的影响, 其实只需要去掉前一个b的第1类贡献即可, 也就是前一个b的"dp[i-1][j-1]".

 

从这个题中, 我们可以总结出, dp算贡献如果直接算不容易的话, 看看能不能用"先多算, 再减掉重复部分"的思路.

更普遍地, 可以考虑充分利用前面相似位置的dp结果.

另外, 这些题都要考虑: 这个题只关心什么, 什么是无所谓的, 这里是化简(就像上面字符串具体的样子);

这个题做的过程中, 我们可以知道什么, 这个东西是不是还能有用,这里是化繁(就像上面前一个相同字符的贡献).

char a[105];
ll dp[105][105];
ll k;
int pre[300];

void init() {
    int n = read();
    k = read();
    scanf("%s", a + 1);
    for (int i = 0; i <= n; ++i) {
        dp[i][0] = 1;
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; ++j) {
            dp[i][j] = dp[i - 1][j - 1];
            dp[i][j] += dp[i - 1][j] - ((pre[a[i]] == 0) ? 0 : dp[pre[a[i]] - 1][j - 1]);
            if (dp[i][j] > k)dp[i][j] = k;
        }
        pre[a[i]] = i;
    }

/*    for (int l = 1; l <= n; ++l) {
        for (int i = 1; i <= n; ++i) {
            printf("[%d,%d]:%lld ", l, i, dp[l][i]);
        }
        enter;
    }*/


    ll ans = 0;
    for (int i = n; i >= 0; --i) {
        ans += min(k, dp[n][i]) * (n - i);
        k -= dp[n][i];
        if (k <= 0)break;
    }
    if (k <= 0)write(ans);
    else write(-1);
    enter;
}