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: Accepted)

use std::collections::BinaryHeap;

#[allow(unused)]
macro_rules! debug {
    ($($format:tt)*) => (write!(std::io::stderr(), $($format)*).unwrap());
}
#[allow(unused)]
macro_rules! debugln {
    ($($format:tt)*) => (writeln!(std::io::stderr(), $($format)*).unwrap());
}

fn main() {
    // 1つの数字
    let s = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().to_owned()
    };
    let n: usize = s.parse().unwrap();

    // 1行ベクトル
    let mut graph_mat = vec![];
    for _ in 0..n {
        let s = {
            let mut s = String::new();
            std::io::stdin().read_line(&mut s).unwrap();
            s.trim_right().to_owned()
        };
        let v: Vec<usize> = s.split("").filter(|&x| x != "").map(|x| x.parse().unwrap()).collect();
        graph_mat.push(v);
    }
    // debugln!("{:?}", graph_mat);

    // 配列形式からリスト形式に変換
    let mut graph_list = vec![vec![]; n];
    for i in 0..n {
        for j in 0..n {
            if graph_mat[i][j] == 1 {
                graph_list[i].push(j);
            }
        }
    }
    // debugln!("{:?}", graph_list);

    // 2部グラフかどうか判定
    // if 2部グラフなら、グラフの直径を求める
    if is_bipartite_graph(&graph_list) {
        // let d = graph_diameter(&graph_list);
        let d = graph_diameter_wf(&graph_mat);
        println!("{}", d + 1);
    } else {
        println!("-1");
    }
}

// 2部グラフか判定
fn is_bipartite_graph(graph_list: &Vec<Vec<usize>>) -> bool {
    let n = graph_list.len();

    let mut stack: Vec<(usize, bool)> = vec![];
    let mut colors = vec![None; n];

    let start = 0;
    stack.push((start, true));

    while !stack.is_empty() {
        let (vertex, color) = stack.pop().unwrap();

        colors[vertex] = Some(color);

        for &next in &graph_list[vertex] {
            match colors[next] {
                Some(next_color) => {
                    if color == next_color {
                        return false;
                    }
                },
                None => stack.push((next, !color)),
            }
        }
    }

    true
}

#[allow(unused)]
fn graph_diameter_wf(ref graph_mat: &Vec<Vec<usize>>) -> usize {
    let d_mat = warshall_floyd(&graph_mat);
    let mut diameter = 0;
    for v in d_mat {
        for d in v {
            if d > diameter {
                diameter = d;
            }
        }
    }

    diameter
}

#[allow(unused)]
fn warshall_floyd(ref graph_mat: &Vec<Vec<usize>>) -> Vec<Vec<usize>> {
    let n = graph_mat.len();

    let mut d = vec![vec![std::usize::MAX >> 2; n]; n];
    for i in 0..n {
        for j in 0..n {
            if graph_mat[i][j] == 1 {
                d[i][j] = 1;
            }
        }
    }
    for i in 0..n {
        d[i][i] = 0;
    }

    for k in 0..n {
        for i in 0..n {
            for j in 0..n {
                if d[i][j] > d[i][k] + d[k][j] {
                    d[i][j] = d[i][k] + d[k][j];
                }
                // debugln!("i = {}, j = {}, k = {}, {:?}", i, j, k, d);
            }
        }
    }

    d
}

// グラフの直径
#[allow(unused)]
fn graph_diameter(graph_list: &Vec<Vec<usize>>) -> usize {
    let start = 0;
    let d_v = dijkstra(start, graph_list);
    // debugln!("{:?}", d_v);

    let mut farthest = start;
    let mut d_max = 0;
    for (v, &d) in d_v.iter().enumerate() {
        if d > d_max {
            d_max = d;
            farthest = v;
        }
    }

    let start = farthest;
    let mut d_max = 0;
    let d_v = dijkstra(start, graph_list);
    for (_, &d) in d_v.iter().enumerate() {
        if d > d_max {
            d_max = d;
        }
    }
    d_max
}

#[derive(PartialEq, Eq, Debug)]
struct Reverse<T> (T);

impl<T: Ord> Ord for Reverse<T> {
    fn cmp(&self, other: &Reverse<T>) -> std::cmp::Ordering {
        self.0.cmp(&other.0).reverse()
    }
}

impl<T: PartialOrd> PartialOrd for Reverse<T> {
    fn partial_cmp(&self, other: &Reverse<T>) -> Option<std::cmp::Ordering> {
        self.0.partial_cmp(&other.0).map(|a| a.reverse())
    }
}

// ダイクストラ
#[allow(unused)]
fn dijkstra(start: usize, graph_list: &Vec<Vec<usize>>) -> Vec<usize> {
    let n = graph_list.len();
    let mut distances = vec![std::usize::MAX >> 2; n];
    distances[start] = 0;

    // (distance, distination)
    let mut queue: BinaryHeap<Reverse<(usize, usize)>> = BinaryHeap::new();
    for vertex in 0..n {
        queue.push(Reverse((distances[vertex], vertex)));
    }

    while !queue.is_empty() {
        let Reverse((d, u)) = queue.pop().unwrap();
        // debugln!("u: {}", u);
        // debugln!("d: {}", d);
        // debugln!("queue: {:?}", queue);
        // debugln!("distances: {:?}", distances);
        for v in &graph_list[u] {
            // debugln!("v: {}", v);
            let alt = d + 1;
            if distances[*v] > alt {
                distances[*v] = alt;
                queue.push(Reverse((alt, *v)))
            }
        }
    }

    distances
}