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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc *bufio.Scanner

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func checked(vertexes []int) bool {
	for _, v := range vertexes {
		if v == 0 {
			return false
		}
	}
	return true
}

func main() {
	sc = bufio.NewScanner(os.Stdin)
	sc.Buffer(make([]byte, 0), 1000000001*3)
	sc.Split(bufio.ScanWords)
	n := nextInt()

	adj := make([][]int, n)
	for i := range adj {
		adj[i] = make([]int, n)
		s := nextStr()
		for j, r := range s {
			if r == '1' {
				adj[i][j] = 1
			}
		}
	}

	divMin, iMin := n, -1
	for i := range adj {
		div := 0
		for _, a := range adj[i] {
			div += a
		}
		if div < divMin {
			divMin, iMin = div, i
		}
	}

	vertexes := make([]int, n)
	count := 1
	vertexes[iMin] = count
	queue := make([]int, 0)
	queue = append(queue, iMin)
	for {
		for len(queue) > 0 && vertexes[queue[0]] == count {
			u := queue[0]
			queue = queue[1:]
			for v, a := range adj[u] {
				switch {
				case a == 0:
					continue
				case vertexes[v] == 0:
					vertexes[v] = count + 1
					queue = append(queue, v)
				case vertexes[v] < count:
					continue
				case vertexes[v] == count:
					fmt.Println(-1)
					return
				}
			}
		}
		if len(queue) == 0 {
			break
		}
		count++
	}

	fmt.Println(count)
}