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 Rust (1.15.1) (judge verdict: Wrong Answer)

pub fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

pub fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

pub fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

pub fn read_col<T: std::str::FromStr>(n: usize) -> Vec<T> {
    (0..n).map(|_| read()).collect()
}

fn dfs(u: usize, p: usize, d: u32, n: usize, mat: &Vec<Vec<u32>>, depth: &mut Vec<u32>) -> bool {
    if depth[u] < 10000 {
        let tmp = d + depth[u];
        if tmp % 2 == 1 {
            return true;
        } else {
            return false;
        }
    }

    depth[u] = d;

    let mut ret = false;

    for v in 0..n {
        if v == u || v == p || mat[u][v] == 0 {
            continue;
        }
        let tmp = dfs(v, u, d + 1, n, mat, depth);
        ret = tmp || ret;
    }

    ret
}

fn main() {
    let n: usize = read();
    let sv: Vec<String> = read_col(n);
    let mut mat: Vec<Vec<u32>> = sv
        .iter()
        .map(|s| s.chars().map(|c| c as u32 - 48).collect())
        .collect();

    let mut depth: Vec<u32> = vec![100000; n];

    if dfs(0, 10000, 0, n, &mat, &mut depth) {
        println!("-1");
        return;
    }

    for i in 0..n {
        for j in 0..n {
            for k in 0..n {
                if i == j || j == k || k == i {
                    continue;
                }
                if mat[i][k] == 0 || mat[k][j] == 0 {
                    continue;
                }
                let tmp = mat[i][k] + mat[k][j];
                if mat[i][j] == 0 || tmp < mat[i][j] {
                    mat[i][j] = tmp;
                }
            }
        }
    }
    let mut ans = 0;

    for i in 0..n {
        for j in i + 1..n {
            if mat[i][j] > ans {
                ans = mat[i][j];
            }
        }
    }

    println!("{}", ans + 1);
}