Since yesterday's Div. 3 round, I've received several PMs asking me to explain my solution to problem E (link here). As far as I'm aware, it's one of the simplest solutions submitted from an implementation standpoint; the code is relatively short and only one line involves nontrivial logic. So, I figured it might be more efficient to just post a writeup publicly. (As an aside, this is not something I do often; I am unable to respond to most PMs I receive asking for problem explanations. I'm writing this post because I received multiple requests related specifically to my solution for this particular problem, and because I happened to have the time. Generally, though, PMing me over Codeforces is unfortunately not an especially efficient way to get help with problems.) I'll try to outline my thought process as I worked through the problem, since I think solving E within three minutes was probably the biggest single contributing factor to my performance in the round.

The first thing I noticed about this problem was that the definition of $$$k$$$-periodic was unusual---typically, for example, `110110110`

would have period $$$3$$$, while `1001000`

would not. After parsing the definition, we see that the basic idea is that there must be one string of `1`

's, each $$$k$$$ spaces apart, and no other `1`

's left in the string.

The intuition we gather from this is that spaces $$$i$$$ and $$$i-k$$$ are probably related. More formally, if we have a string such that the last `1`

is at position $$$i-K$$$, then we can create a string such that the last `1`

is at position $$$i$$$ by taking the same string, then changing the character in position $$$i$$$ to a `1`

.

Our ability to reuse computation for earlier positions in the string to help us deal with later positions motivates a DP approach. We define our state as follows: let $$$dp[i]$$$ be the maximum value of the number of `1`

's kept as `1`

's (rather than changed to `0`

) minus the number of `0`

's changed to `1`

's in order to get a valid string that has its last `1`

at position $$$i$$$, if it has any `1`

's at all. Then, our answer is the minimum value of $$$cnt_1 - dp[i]$$$ over all $$$i$$$, where $$$cnt_1$$$ is the number of `1`

's in the whole string. This is because, since $$$dp[i]$$$ counts unchanged `1`

's minus changed `0`

's, $$$cnt_1 - dp[i]$$$ counts changed `1`

's plus changed `0`

's, which is exactly what we want.

This seems like a very bizarre DP state, but it's actually quite nicely motivated. The key idea is that since we're forming a chain of `1`

's separated by $$$k$$$ spaces each, and our transition will thus relate $$$dp[i]$$$ to $$$dp[i-k]$$$, we probably want to form a state based only on changes made within the chain of positions we're changing to `1`

's, so that we don't need to worry about any positions after $$$i$$$ or outside this chain. Then, within our chain, we keep all the `1`

's as `1`

's and change all the `0`

's to `1`

's. Keeping `1`

's that were in the string already effectively saves us from performing a modification, while changing `0`

's effectively forces us to perform a modification. Thus, $$$dp[i]$$$ is effectively the number of modifications we saved minus the number of extra modifications we added compared to if we changed all the elements of the string to `0`

.

Then, we just need to figure out the transitions. First, it is possible for $$$dp[i]$$$ to equal $$$S[i]$$$. If $$$S[i] = 0$$$, then we can achieve the string with no `1`

's without changing any `0`

's to `1`

's, so $$$dp[i]$$$ can equal $$$0$$$. If $$$S[i] = 1$$$, then we can save one modification by creating the string where the only `1`

is at position $$$i$$$.

This leaves one case left: taking a string ending at $$$i-K$$$, and adding a $$$1$$$. Starting with $$$dp[i-K]$$$, this forces us to make one extra change if $$$S[i] = 0$$$, because we now need to change position $$$i$$$ to a `1`

. However, it saves us one modification if $$$S[i] = 1$$$, because we no longer need to change position $$$i$$$ to a `0`

. This can be written concisely as `dp[i-K] - 1 + 2 * (S[i] - '0')`

, since $$$dp[i] = dp[i-K] + 1$$$ if $$$S[i] = 1$$$ or $$$dp[i-K] - 1$$$ if $$$S[i] = 0$$$.

From here, we can compute the DP table in $$$O(N)$$$ and use it to generate the answer. The relevant portion of my code is below.

```
int T; cin >> T;
while(T--) {
int N, K; cin >> N >> K;
string S; cin >> S;
int dp[N];
int ans = 0;
F0R(i, N) {
dp[i] = S[i] - '0';
if (i >= K) {
dp[i] = max(dp[i], dp[i-K] - 1 + 2 * (S[i] - '0'));
}
ans = max(ans, dp[i]);
}
int cnt = 0; F0R(i, N) cnt += S[i] - '0';
cout << cnt-ans << nl;
}
```

Thank you "combo"thermal!! *saw no comments for such a good post :/ *

Thank you!

Thank you Sir!