I did it in a slightly different way.

let dp[i] be the minimum number of ways substring s[1:i] can be k-periodic with the ith bulb switched on. Now while evaluating dp[i] we can face 2 situations.

1. If (i-k)th bulb is off the we can say that in the substring s[1:i] the ith bulb is the only bulb which is on. Then:

dp[i] = (
        (number of ways to switch off all the bulbs from 1 to i-1) + 
        (1 if ith bulb is originally off)
        )

2 If (i-k)th bulb is on, then

dp[i] = (
        dp[i-k] + 
        (number of moves required to switch off all the bulbs between i and i-k) + 
        (1 if the ith bulb is originally off)
        )

at each i I also considered the case that it can be the last bulb which is on and updated the ans accordingly. ans = min(ans, dp[i] + (number of ways to switch off all the bulbs from i + 1 to n))

int solve() {
    int n, k; cin >> n >> k;
    string s; cin >> s;
    
    // Evaluating Prefix Sum
    lld psum[n]; psum[0] = (s[0] == '1');
    for (int i = 1; i < n; i++) psum[i] = psum[i-1] + (s[i] == '1');

    // dp[i] : min number of moves required to make s[0:i]
    //          k-periodic with ith bulb switched on
    int dp[n] = {0};
    int ans = max(0, psum[n-1] - 1);

    // Initializing dp
    for (int i = 0; i < k; i++) dp[i] = psum[i] - (s[i] == '1');

    // Evauating DP
    for (int i = k; i < n; i++) {
        dp[i] = (s[i] == '0') + min(
            dp[i-k] + (psum[i] - psum[i - k] - (s[i] == '1')),
            psum[i] - (s[i] == '1')
            );

        // updating ans asuming ith bulb is the last on bulb
        ans = min (ans, dp[i] + (psum[n-1] - psum[i]));
    }

    return ans;
}

Step 1: Count the number of ones in the given string . Let it be "Ones" Step 2: Split the whole array into k different arrays, such that element i of the original array is now part of (i%k)th array . Now , we have to choose the best of these k arrays . Solving each array We need to find the starting and ending position in this array such that, the difference of ones and zeros is maximum in this range i.e. we need to set minimum number of 0s to 1s. Now, all we need is, number of 0s in this range + number of 1s outside this range + number of 1s in rest of the arrays (it can be counted with the help of "Ones", which we stored in step one. Here is the Implementation