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.7.1) (judge verdict: Accepted)

#!/usr/bin/env ruby

require 'set'

debug = false

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

def bit_search(bit_num)
  for x in [*0...2**bit_num]
    # true, falseの配列がyieldされる
    yield x.to_s(2).rjust(bit_num, '0').split('').map { |s| s == '1' }
  end
end

H, W, K = get_ints
S = Array.new(H) { [] }

H.times do |i|
  S[i] = gets.chomp.split('')
end

ans = H - 1 + W - 1
# 横線はbit全探索
bit_search(H-1) do |arr|
  tate = []
  youso = [0]
  arr.each.with_index do |b, i|
    if b
      tate.push(youso)
      youso = [i+1]
    else
      youso.push(i+1)
    end
  end
  tate.push(youso)

  # 縦に線を引いていく
  stock = Array.new(tate.length, 0)
  ws = Set.new
  ws.add(-1)
  impossible = false
  for w in [*0...W]
    sub = Array.new(tate.length, 0)
    tate.each.with_index do |t_arr, i|
      t_arr.each { |t| sub[i] += 1 if S[t][w] == '1' }
    end
    if stock.zip(sub).any? { |a, b| a + b > K }
      # 越したので線を引く
      if ws.include?(w-1)
        impossible = true
        break
      end
      ws.add(w-1)
      stock = sub
    else
      stock = stock.zip(sub).map { |a, b| a + b }
    end
  end

  next if impossible

  res = arr.count { |x| x } + (ws.length - 1)
  ans = res if res < ans
end

puts ans