Problem:
Score : 500 points

Problem Statement

Given is a connected undirected graph with N vertices and M edges. The vertices are numbered 1 to N, and the edges are described by a grid of characters S.
If S_{i,j} is 1, there is an edge connecting Vertex i and j; otherwise, there is no such edge.

Determine whether it is possible to divide the vertices into non-empty sets V_1, \dots, V_k such that the following condition is satisfied. If the answer is yes, find the maximum possible number of sets, k, in such a division.

Every edge connects two vertices belonging to two "adjacent" sets. More formally, for every edge (i,j), there exists 1\leq t\leq k-1 such that i\in V_t,j\in V_{t+1} or i\in V_{t+1},j\in V_t holds.

Constraints

2 \leq N \leq 200

S_{i,j} is 0 or 1.

S_{i,i} is 0.

S_{i,j}=S_{j,i}

The given graph is connected.

N is an integer.

Input

Input is given from Standard Input in the following format:

N
S_{1,1}...S_{1,N}
:
S_{N,1}...S_{N,N}

Output

If it is impossible to divide the vertices into sets so that the condition is satisfied, print -1.
Otherwise, print the maximum possible number of sets, k, in a division that satisfies the condition.

Sample Input 1

2
01
10

Sample Output 1

2

We can put Vertex 1 in V_1 and Vertex 2 in V_2.

Sample Input 2

3
011
101
110

Sample Output 2

-1

Sample Input 3

6
010110
101001
010100
101000
100000
010000

Sample Output 3

4

Solution in Ruby (2.3.3) (judge verdict: Accepted)

class Array
  def warshall_floyd
    v = size

    dist = map(&:dup)

    v.times do |k|
      v.times do |i|
        v.times do |j|
          cost = dist[i][k] + dist[k][j]
          dist[i][j] = cost if dist[i][j] > cost
        end
      end
    end

    dist
  end
end

N = gets.to_i
S = N.times.map { gets.chomp.chars.map(&:to_i) }


module Graph
  class Tree
    def initialize(edges)
      @edges = edges
    end

    def diameter
      r = @edges.keys.first
      v, _ = farthest_vertex(r)
      u, d = farthest_vertex(v)
      [v, u, d]
    end

    private

    def farthest_vertex(s)
      queue = [[s, 0]]
      dist = -1
      fv = -1
      visited = Hash.new(false)

      until queue.empty?
        v, d = queue.shift

        next if visited[v]
        visited[v] = true

        if dist < d
          dist = d
          fv = v
        end

        @edges[v].each do |u|
          queue.push([u, d + 1])
        end
      end

      [fv, dist]
    end
  end
end

edges = Hash.new { |h, k| h[k] = [] }
e = Array.new(N) { Array.new(N, Float::INFINITY) }

S.each_with_index do |row, i|
  row.each_with_index do |t, j|
    if i == j
      e[i][j] = 0
    end

    next if t.zero?

    e[i][j] = 1
    edges[i] << j
  end
end

e = e.warshall_floyd
tree = Graph::Tree.new(edges)

md = 0
s = -1

e.each_with_index do |row, i|
  row.each do |d, j|
    if md < d
      md = d
      s = i
    end
  end
end

# root, _, dist = tree.diameter

queue = [[s]]
visited = Hash.new(false)

until queue.empty?
  list = queue.shift

  next if list.empty?

  vs = []

  list.each do |v|
    visited[v] = true

    edges[v].each do |u|
      next if visited[u]

      vs << u
    end
  end

  vs.uniq!

  vs.each do |i|
    vs.each do |j|
      next if i == j

      if S[i][j] == 1
        puts -1
        exit
      end
    end
  end

  queue.push(vs)
end

puts md + 1