2020/5/1每日一咕

2020/5/1

1.字符串dp

Problem - 1183H - Codeforces
A subsequence is a string that can be derived from another string by deleting some or no symbols without changing the order of the remaining symbols. Characters to be deleted are not required to go successively, there can be any gaps between them. For example, for the string “abaca” the following strings are subsequences: “abaca”, “aba”, “aaa”, “a” and “” (empty string). But the following strings are not subsequences: “aabaca”, “cb” and “bcaa”.

You are given a string ss consisting of nn lowercase Latin letters.

In one move you can take any subsequence tt of the given string and add it to the set $S$ The set $S$ can’t contain duplicates. This move costs $n-|t|$, where $|t|$ is the length of the added subsequence (i.e. the price equals to the number of the deleted characters).

Your task is to find out the minimum possible total cost to obtain a set $S$ of size $k$ or report that it is impossible to do so.

Input

The first line of the input contains two integers $n$ and $k(1\le n\le 100,1\le k\le 10^{12})$ — the length of the string and the size of the set, correspondingly.

The second line of the input contains a string ss consisting of nn lowercase Latin letters.

Output

Print one integer — if it is impossible to obtain the set $S$ of size $k$, print -1. Otherwise, print the minimum possible total cost to do it.

题意大概就是给出一个长度为n的字符串，求你找出k个子序列，每个子序列$t$对答案贡献$n-|t|$，求最小贡献，找不到就是-1。
很明显就是要找出不同长度本质不同的子序列的数量，如果只是求本质不同的字符串的数量那就是$dp[i]=dp[i-1]\ast 2-dp[last[s[i]]$。
但是这题还需要各个长度的，这个n也比较小，于是再开一维$dp[i][j]$表示前$i$个字符中删除了$j$个字符得到的子序列数量。$dp[i][j]=dp[i-1][j]$（删除当前这个字符）+$dp[i-1][j-1]$（加上这个字符）得到的字符串。
一样考虑重复问题，还需要减去$i-1-j==last[s[i]]-1-x中的x$，故再$-dp[last[s[i]]-1][last[s[i]-(i-j)]$

	ll n, k;
    char s[maxn];
    cin >> n >> k >> s + 1;
    vector<vector<ll>> dp(n + 1, vector<ll>(n + 1));
    vector<int> last(300, -1);
    dp[0][0] = 1;
    for (int i = 1; i <= n; ++i) {
        dp[i][0] = 1;
        for (int j = 1; j <= i; ++j) {
            dp[i][j] += dp[i - 1][j - 1] + dp[i - 1][j];
            if (last[s[i]] >= (i - j)) {
                dp[i][j] -= dp[last[s[i]] - 1][last[s[i]] - (i - j)];
            }
        }
        last[s[i]] = i;
    }
    ll ans = 0;
    for (int i = 0; i <= n; ++i) {
        ans += min(k, dp[n][i]) * i;
        k -= min(k, dp[n][i]);
        if (k == 0) {
            cout << ans << endl;
            return 0;
        }
    }
    cout << -1 << endl;

2.思维 DP

Problem - 1197D - Codeforces
You are given an array $a_1,a_2,\dots ,a_n$ and two integers m and k.

You can choose some subarray $a_l,a_{l+1},\dots ,a_{r-1},a_r.$

The cost of subarray $a_l,a_{l+1},\dots ,a_{r-1},a_r.$ is equal to ${\sum }_{i=l}^r{a}_i-k\lceil \frac{r-l+1}{m}\rceil$, where ⌈x⌉ is the least integer greater than or equal to x.

The cost of empty subarray is equal to zero.

For example, if m=3, k=10 and a=[2,−4,15,−3,4,8,3], then the cost of some subarrays are:

$a_3\dots a_3:15-k\lceil \frac{1}{3}\rceil =15-10=5;$
$a_3\dots a_4:(15-3)-k\lceil \frac{2}{3}\rceil =12-10=2;$
$a_3\dots a_5:(15-3+4)-k\lceil \frac{3}{3}\rceil =16-10=6;$
$a_3\dots a_6:(15-3+4+8)-k\lceil \frac{4}{3}\rceil =24-20=4;$
$a_3\dots a_7:(15-3+4+8+3)-k\lceil \frac{5}{3}\rceil =27-20=7.$
Your task is to find the maximum cost of some subarray (possibly empty) of array a.

Input
The first line contains three integers n, m, and k $(1\le n\le 3\cdot 10^5,1\le m\le 10,1\le k\le 10^9).$

The second line contains n integers $a_1,a_2,\dots ,a_n(-10^9\le a_i\le 10^9).$

Output
Print the maximum cost of some subarray of array a.
题意就是选择子串$[l,r]$使得${\sum }_{i=l}^r{a}_i-k\lceil \frac{r-l+1}{m}\rceil$最大
有点像最大子段和，但是不是。不过也是dp思想。
$dp[i][j]$表示右端点为i，长度$（len-1）\%m=j$的子串的贡献。
因为每过边界m，就减一个k，此时就可以抉择，是否重新开始。

1. （j==0，即长度%m==1）$dp[i][j]=max(dp[i-1][m-1],0)+a[i]-k$
2. （j！=0）$dp[i][j]=dp[i-1][j-1]+a[i]$未达边界，不必-k
   $dp起点为dp[0][0]=a[0]-k$，即右端点在0位置，长度为1时的ans。

两个小细节

1. ans初始化是$max(a[0]-k,0ll);$
2. 以及二重循环$j<min(i+1,m)$因为太少不够选择是无法被转移的。

   ll n, m, k;
   cin >> n >> m >> k;
   vector<ll> a(n);
   for (auto &it : a) cin >> it;
   vector<vector<ll>> dp(n, vector<ll>(m, 0));
   ll ans = max(a[0] - k, 0ll);
   dp[0][0] = a[0] - k;
   for (ll i = 1; i < n; ++i) {
       for (ll j = 0; j < min(i + 1, m); ++j) {
           if (j == 0)
               dp[i][j] = max(dp[i - 1][m - 1] + a[i], a[i]) - k;
           else
               dp[i][j] = dp[i - 1][j - 1] + a[i];
           ans = max(ans, dp[i][j]);
       }
   }
   cout << ans << endl;