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

int rsum(int psum[], int l, int r) {
  if (l == 0) {
    return psum[r];
  }
  return psum[r] - psum[l - 1];
}

bool possible(int n, int m, int k, bool a[], int psum[], int x) {
  int l_bounds[n];
  int l = n - 1;
  for (int i = n - 1; i >= 0; i--) {
    while (l >= 0 && i - l + 1 < x) {
      l--;
    }
    while (l > 0 && a[l - 1]) {
      l--;
    }
    if (l <= i - x + 1) {
      l_bounds[i] = l;
    } else {
      l_bounds[i] = -1;
    }
  }

  // dp[i][j] = min number of 0s turned into 1s in order to create j streaks of at least x using 0...i
  int dp[n][k + 1];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j <= k; j++) {
      dp[i][j] = n + 1;
    }
  }
  bool res = false;
  for (int i = 0; i < n; i++) {
    for (int j = 1; j <= k; j++) {
      if (i > 0) {
	dp[i][j] = dp[i - 1][j];
      }
      if (l_bounds[i] != -1) {
	int cost = i - l_bounds[i] + 1 - rsum(psum, l_bounds[i], i);
	int ll = l_bounds[i] - 2;
	if (j == 1) {
	  dp[i][j] = min(dp[i][j], cost);
	} else if (ll >= 0 && dp[ll][j - 1] != n + 1) {
	  dp[i][j] = min(dp[i][j], dp[ll][j - 1] + cost);
	}
      }
      if (j == k && dp[i][j] <= x && (i == n - 1 || a[i + 1] == 0)) {
	res = true;
      }
    }
  }
  return res;
}

int main() {
  int n, m, k;
  cin >> n >> m >> k;
  string s;
  cin >> s;
  bool a[n];
  int psum[n] = {0};
  for (int i = 0; i < n; i++) {
    if (s[i] == '1') {
      a[i] = 1;
    } else {
      a[i] = 0;
    }
    psum[i] = (i > 0 ? psum[i - 1] : 0) + a[i];
  }

  int l = 1;
  int r = n;
  int res = -1;
  while (l <= r) {
    int m = (l + r) / 2;
    if (possible(n, m, k, a, psum, m)) {
      res = m;
      l = m + 1;
    } else {
      r = m - 1;
    }
  }
  cout << res << endl;
}