output_description: 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.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      S_{1,1}...S_{1,N}
      :
      S_{N,1}...S_{N,N}
attempt: # -*- coding: utf-8 -*-
  
  import sys
  from collections import deque
  
  
  def input():
      return sys.stdin.readline().strip()
  
  
  def list2d(a, b, c):
      return [[c] * b for i in range(a)]
  
  
  def list3d(a, b, c, d):
      return [[[d] * c for j in range(b)] for i in range(a)]
  
  
  def list4d(a, b, c, d, e):
      return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
  
  
  def ceil(x, y=1):
      return int(-(-x // y))
  
  
  def INT():
      return int(input())
  
  
  def MAP():
      return map(int, input().split())
  
  
  def LIST(N=None):
      return list(MAP()) if N is None else [INT() for i in range(N)]
  
  
  def Yes():
      print("Yes")
  
  
  def No():
      print("No")
  
  
  def YES():
      print("YES")
  
  
  def NO():
      print("NO")
  
  
  sys.setrecursionlimit(10**9)
  INF = float("inf")
  MOD = 10**9 + 7
  
  N = INT()
  G = [None] * N
  for i in range(N):
      G[i] = list(map(int, input()))
  
  nodes = [[] for i in range(N)]
  for i in range(N):
      for j in range(N):
          if G[i][j]:
              nodes[i].append(j)
              nodes[j].append(i)
  
  
  def bfs(start):
      visited = list2d(N, N, 0)
      group = [-1] * N
      que = deque()
      que.append((start, 1))
      mx = 0
      while que:
          u, cnt = que.popleft()
          if group[u] == -1:
              group[u] = cnt
          elif group[u] == cnt:
              continue
          else:
              return -1
          mx = max(mx, cnt)
          for v in nodes[u]:
              if visited[u][v]:
                  continue
              visited[u][v] = visited[v][u] = 1
              que.append((v, cnt + 1))
      return mx
  
  
  ans = -1
  for i in range(N):
      ans = max(ans, bfs(i))
  print(ans)
  
problem_description: 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.
samples: [{"input": "2\n    01\n    10", "output": "2\n    \n\nWe can put Vertex 1 in V_1 and Vertex 2 in V_2.\n\n* * *"}, {"input": "3\n    011\n    101\n    110", "output": "-1\n    \n\n* * *"}, {"input": "6\n    010110\n    101001\n    010100\n    101000\n    100000\n    010000", "output": "4"}]