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 PyPy3 (2.4.0) (judge verdict: Wrong Answer)

import queue
import sys
from collections import defaultdict

input = sys.stdin.readline


class AtCoder:
    def main(self):
        N = int(input())
        # S = [list(map(int, list(input().rstrip())))for _ in range(N)]

        edge = defaultdict(set)
        for i in range(N):
            for j, flag in enumerate(list(input().rstrip())):
                if int(flag):
                    edge[i + 1].add(j + 1)

        ans = -1
        for i in range(N):
            q = queue.Queue()
            flood_fill = set()
            q.put((i + 1, 0))
            is_bipartite_graph = True
            distance = 0
            while not q.empty():
                node = q.get()
                flood_fill.add(node[0])
                next_nodes = edge[node[0]]

                # 2部グラフ判定
                for next_node in next_nodes:
                    if not edge[next_node].isdisjoint(next_nodes):
                        is_bipartite_graph = False
                        break
                    elif next_node not in flood_fill:
                        q.put((next_node, node[1] + 1))
                        distance = max(distance, node[1] + 1)
                if not is_bipartite_graph:
                    break

            if is_bipartite_graph:
                ans = max(ans, distance + 1)

        print(ans)


# Run main
if __name__ == '__main__':
    AtCoder().main()