import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

public class Main {

  static int[][] map;
  static int min = Integer.MAX_VALUE;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int[] array = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
    map = new int[array[0]][array[1]];

    for (int i = 0; i < map.length; i++) {
      int[] input = Arrays.stream(br.readLine().split("")).mapToInt(Integer::parseInt).toArray();
      for (int j = 0; j < map[i].length; j++) {
        map[i][j] = input[j];
      }
    }

    boolean[][] visited = new boolean[array[0]][array[1]];
    bfs(new Progress(new int[]{0, 0}, visited, 0));
    System.out.println(min);
  }

  public static void bfs(Progress prog) {
    Queue<Progress> queue = new LinkedList<>();
    prog.visited[prog.loc[0]][prog.loc[1]] = true;
    prog.count += 1;
    queue.add(prog);
    while (!queue.isEmpty()) {
      Progress newProg = queue.poll();
      if (newProg.loc[0] == map.length - 1 && newProg.loc[1] == map[0].length - 1) {
        min = Math.min(min, newProg.count);
        return;
      }

      int[] dx = {0, 0, 1, -1};
      int[] dy = {1, -1, 0, 0};

      for (int k = 0; k < 4; k++) {
        int nx = newProg.loc[0] + dx[k];
        int ny = newProg.loc[1] + dy[k];
        if (nx >= 0 && nx < map.length && ny >= 0 && ny < map[0].length) {
          if (!newProg.visited[nx][ny] && map[nx][ny] != 0) {
            newProg.visited[nx][ny] = true;
            queue.add(new Progress(new int[]{nx, ny}, newProg.visited, newProg.count + 1));
          }
        }
      }
    }
  }
  
  static class Progress {

    int[] loc;
    boolean[][] visited;
    int count;

    Progress(int[] loc, boolean[][] visited, int count) {
      this.loc = loc;
      this.visited = visited;
      this.count = count;
    }
  }

}