import java.io.{BufferedOutputStream, BufferedReader, InputStreamReader, PrintWriter}

object Main {
  def main(args: Array[String]): Unit = {
    val in = new BufferedReader(new InputStreamReader(System.in))
    val out = new PrintWriter(new BufferedOutputStream(System.out))
    val Array(h, w, k) = in.readLine().split("\\s+").map(_.toInt)

    val choco = Array.ofDim[Array[Int]](h)
    for (hi <- choco.indices) {
      choco(hi) = in.readLine().map(_.toInt - '0').toArray
    }

    def pow(n: Int, k: Int): Int = {
      if (k == 0) {
        1
      } else {
        n * pow(n, k - 1)
      }
    }

    var min = (h - 1) * (w - 1)

    for (hPattern <- 0 until pow(2, h - 1)) {
      val hi2ci = Array.ofDim[Int](h)
      for (hi <- 1 until h) {
        hi2ci(hi) = hi2ci(hi - 1) + ((hPattern >> (hi - 1)) & 1)
      }

      def countVertical(): Option[Int] = {
        def greedy(sw: Int): Int = {
          val columnCount = Array.ofDim[Int](hi2ci.max + 1)

          for (wi <- sw until w) {
            for (hi <- 0 until h) {
              if (choco(hi)(wi) == 1) {
                if (columnCount(hi2ci(hi)) + 1 > k) {
                  return wi - 1
                }
                columnCount(hi2ci(hi)) += 1
              }
            }
          }
          w - 1
        }

        var verticalCount = 0
        var prevVertical = -1
        var wi = 0
        while (wi < w) {
          val vertical = greedy(wi)
          if (vertical == prevVertical) {
            return None
          } else {
            prevVertical = vertical
            wi = vertical + 1
            if (w - 1 != vertical) {
              verticalCount += 1
            }
          }
        }

        Some(verticalCount)
      }

      countVertical() match {
        case None =>
        case Some(verticalCount) =>
          min = Math.min(min, verticalCount + hi2ci.max)
      }
    }

    out.println(min)

    out.flush()
  }
}
