Problem:
Score : 500 points

Problem Statement

We have a chocolate bar partitioned into H horizontal rows and W vertical columns of squares.

The square (i, j) at the i-th row from the top and the j-th column from the left is dark if S_{i,j} is 0, and white if S_{i,j} is 1.

We will cut the bar some number of times to divide it into some number of blocks. In each cut, we cut the whole bar by a line running along some boundaries of squares from end to end of the bar.

How many times do we need to cut the bar so that every block after the cuts has K or less white squares?

Constraints

1 \leq H \leq 10

1 \leq W \leq 1000

1 \leq K \leq H \times W

S_{i,j} is 0 or 1.

Input

Input is given from Standard Input in the following format:

H W K
S_{1,1}S_{1,2}...S_{1,W}
:
S_{H,1}S_{H,2}...S_{H,W}

Output

Print the number of minimum times the bar needs to be cut so that every block after the cuts has K or less white squares.

Sample Input 1

3 5 4
11100
10001
00111

Sample Output 1

2

For example, cutting between the 1-st and 2-nd rows and between the 3-rd and 4-th columns - as shown in the figure to the left - works.

Note that we cannot cut the bar in the ways shown in the two figures to the right.

Sample Input 2

3 5 8
11100
10001
00111

Sample Output 2

0

No cut is needed.

Sample Input 3

4 10 4
1110010010
1000101110
0011101001
1101000111

Sample Output 3

3

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)

H, W, K =  gets.chomp.split.map(&:to_i)

s = []
H.times do
  row = gets.chomp.chars.map(&:to_i)
  s << row
end

ans = 10**10

[0, 1].repeated_permutation(H-1) do |bits|
  # p bits
  # 1のときは斬る

  pieces = []
  tmp_row = []
  tmp_row << s[0]

  (H-1).times do |i|
    if bits[i] == 1
      pieces << tmp_row
      tmp_row = []
      tmp_row << s[i+1]
    else
      tmp_row << s[i+1]
    end

    # 最後のときは足しておく
    if H-2 == i
      pieces << tmp_row
    end
  end

  tmp_ans = 0

  splits = Hash.new(false)

  pieces.each do |piece|
    tmp_count = 0
    p_h = piece.size


    W.times do |j|
      tmp_count = 0 if splits[j+1] == true
      # 今の実装だと、すでにたてに切れ目をいれてても次のpieceに引き継いでいない
      # p j
      # その列におけるたての合計
      tmp_col_cnt = 0
      p_h.times do |i|
        tmp_col_cnt += piece[i][j]
      end
      # p tmp_count
      if tmp_col_cnt + tmp_count > K
        if j == 0
          # 1列目でKを超えてしまったら分割できないので無限に大きくする
          tmp_ans += 10**10
        end

        splits[j] = true

        tmp_ans += 1
        # 答えにプラスして、今回ののみ記録する
        tmp_count = tmp_col_cnt

        # p "Kを超えたときの一時的な答えは#{tmp_ans}"
      else
        tmp_count = tmp_col_cnt + tmp_count
      end
    end
  end

  # ビットの数
  # p bits.count(1)
  # p tmp_ans

  ans = [ans, tmp_ans + bits.count(1)].min
end

puts ans