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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = Integer.parseInt(sc.next());

        // graph list
        LinkedList<ArrayList<Integer>> edge_2 = new LinkedList<ArrayList<Integer>>();
        for (int i=0;i<N;i++) {
            ArrayList<Integer> add = new ArrayList<Integer>();
            edge_2.add(add);
        }
        ArrayList<ArrayList<Integer>> edge = new ArrayList<ArrayList<Integer>>(edge_2);
      

        //graph matrix
        char[][] graph = new char[N][N];
        for (int i=0;i<N;i++) {
            String S = sc.next();
            for (int j=0;j<N;j++) {
                char flag = S.charAt(j);
                graph[i][j] = flag;

                // graph list add
                if (flag=='1') {
                    edge.get(i).add(j);
                }
            }
        }
        int flag = 0;
        int tmp_depth = 0;

        // loop:for (int j=0;j<N;j++) {
        //     int[] used = new int[N];
        //     for (int i=0;i<N;i++) {
        //         used[i] = -1;
        //     }
        //     int root = j;
        //     ArrayDeque<int[]> queue = new ArrayDeque<int[]>();
        //     int[] add = {root, 0};
        //     queue.add(add);
        //     while (!queue.isEmpty()) {
        //         int[] rem = queue.remove();int index = rem[0];int depth = rem[1];
        //         // System.out.println("rem : " + Arrays.toString(rem));
        //         tmp_depth = Math.max(tmp_depth, depth);
        //         used[index] = depth;
        //         ArrayList<Integer> edge_list = edge.get(index);
        //         for (Integer i : edge_list) {
        //             if (used[i]==-1) {
        //                 int[] add_q = {i, depth+1};
        //                 queue.add(add_q);
        //             } else if (used[i]!=depth-1) {
        //                 flag=1;
        //                 break loop;
        //             }
        //         }
        //     }
        // }
        // if (flag==1) {
        //     System.out.println(-1);
        // } else {
        //     System.out.println(tmp_depth+1);
        // }

        // for (ArrayList<Integer> aaa : edge) {
            // System.out.println(aaa);
        // }
        // System.out.println("used " + Arrays.toString(used));
    }
}