// https://www.geeksforgeeks.org/shortest-path-in-a-binary-maze/
// Plus court chemin entre deux cellules.
// Version "BFS" - parcours en largeur
#include <bits/stdc++.h>
using namespace std;

int m = 0, n = 0; // Lignes, colonnes

// Coordonnées dans la matrice
struct point_t
{
	int x, y;

	point_t() : x(0), y(0) { }
	point_t(int _x, int _y) : x(_x), y(_y) { }
};

// Structure de noeud pour la file d'attente utilisée dans le parcours BFS
struct node_t
{
	point_t pt;	// Coordonnées d'une cellule
	int dist;	// Distance de la cellule à l'origine (0, 0)
};

// Vérification si {i, j} est une cellule valide ou non
bool isValid(const int i, const int j)
{
	return i >= 0 && i < m && j >= 0 && j < n;
} // isValid()

// Directions d'un "4-voisinage"
vector<int> rowNum = {-1,  0, 0, 1};
vector<int> colNum = { 0, -1, 1, 0};

// Distance la plus courte entre une cellule src et une cellule dst.
// Parcours en largeur
int BFS(const vector<vector<int>> &mat, const point_t src, const point_t dst)
{
	// Est-ce que les deux cellules contiennent un '1' ?
	if(mat[src.x][src.y] == 0 || mat[dst.x][dst.y] == 0)
		return -1;

	auto visited = vector<vector<bool>>(m, vector<bool>(n, false));
	
	// Marque la cellule source comme visitée
	visited[src.x][src.y] = true;

	// File d'attente pour parcours en largeur
	queue<node_t> q;
	
	// La distance  de la cellule source est 0
	node_t s = {src, 0};
	q.push(s); // On enfile la cellule source

	// Parcours en largeur à partir de la cellule source
	while(!q.empty())
	{
		node_t curr = q.front();
		point_t pt = curr.pt;

		// Destination atteinte, on a fini
		if(pt.x == dst.x && pt.y == dst.y)
			return curr.dist;

		q.pop(); // on défile la cellule en tête de file
		// et on enfile ses cellules adjacentes :
		for(size_t i = 0; i < rowNum.size(); i++) // pour chacune des 4 directions
		{
			int row = pt.x + rowNum[i];
			int col = pt.y + colNum[i];
			
			// Si la cellule adjacente est valide et non visitée, on l'enfile
			if(isValid(row, col) && mat[row][col] && !visited[row][col])
			{
				visited[row][col] = true;
				node_t Adjcell = {{row, col}, curr.dist + 1};
				q.push(Adjcell);
			}
		}
	}

	// -1 si la destination ne peut pas être atteinte
	return -1;
} // BFS()

int main()
{
	// Lecture des données
	cin >> m >> n; // lignes, colonnes

	auto mat = vector<vector<int>>(m, vector<int>(n, 0));
	for(int i = 0; i < m * n; i++)
		cin >> mat[i / n][i % n];

	// Résolution
	point_t src = {0, 0};
	point_t dst = {m - 1, n - 1};

	int dist = BFS(mat, src, dst); // Parcours en largeur

	if(dist != -1)
		cout << dist << '\n';
	else
		cout << "No solution.\n";

	return 0;
} // main()