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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <algorithm>
#include <fstream>
#include <vector>
#include <deque>
#include <assert.h>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <stdio.h>
#include <string.h>
#include <utility>
#include <math.h>
#include <bitset>
#include <iomanip>
#include <complex>
using namespace std;
//#define int long long
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef long long ll;
#define X first
#define Y second
#define all(o) o.begin(), o.end()
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0)

int gcd(int x,int y){ return (!y ? x : gcd(y, x%y)); }
const int maxn = 200 + 10;
vi adj[maxn];
int d[maxn], par[maxn];
int gp(int v){
	return(par[v] == v ? v : par[v] = gp(par[v]));
}
bool mrg(int u,int v){
	u = gp(u);
	v = gp(v);
	if(u == v)
		return false;
	par[u] = v;
	return true;
}
int32_t main(){
	IOS;
	int n;
	cin >> n;
	int cmp = n;
	bool cyc = false;
	for(int i=0; i<n; i++)
		par[i] = i;
	for(int i=0; i<n; i++){
		string s;
		cin >> s;
		for(int j=0; j<n; j++)
			if(s[j] == '1'){
				adj[i].push_back(j);
				if(j > i && mrg(i, j) == false)
					cyc = true;
			}
	}
	bool can = 1;
	int mx = 0;
	int ans = 1000;
	for(int i=0; i<n; i++){
		queue<int> q;
		q.push(i);
		memset(d, 63, sizeof d);
		d[i] = 0;
		while(q.size()){
			int v = q.front();
			q.pop();
			for(auto u : adj[v]){
				if(d[u] > d[v] + 1){
					d[u] = d[v] + 1;
					mx = max(mx, d[u]);
					q.push(u);
				}
				else if((d[u] - d[v]) % 2 == 0)
					can = 0;
				else if(d[u] < d[v]){
					ans = min(ans, d[u] + d[v] + 1);
				}
			}
		}
	}
	//cout << cyc << endl;
	if(!can)
		cout << -1 << endl;
	else if(cyc)
		cout << ans / 2 << endl;
	else
		cout << mx + 1 << endl;		
}