#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MAXN = 55, INF = 1e9;
string arr[MAXN];

int simple_dist[MAXN * MAXN][MAXN * MAXN];

int h, w;

vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};

int d[MAXN * MAXN][MAXN * MAXN][4];
char used[MAXN * MAXN][MAXN * MAXN][4];

vector<int> help[MAXN * MAXN][4];

int get_w(int u, int d, int mem = -1) {
  bool f = false;
  for (int x : help[u][d]) {
    if (x == mem) f = true;
  }
  return help[u][d].size() - f;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  /// auto start = clock();

  cin >> h >> w;
  for (int i = 0; i < h; ++i) {
    cin >> arr[i];
    /// arr[i] = string(w, '#');
  }

  for (int i = 0; i <= h; ++i) {
    for (int j = 0; j <= w; ++j) {
      int u = i * (w + 1) + j;
      for (int d = 0; d < 4; ++d) {
        int i1 = i + dx[d], j1 = j + dy[d];
        if (i1 < 0 || i1 > h || j1 < 0 || j1 > w) continue;
        int v = i1 * (w + 1) + j1;
        int ui = u / (w + 1), uj = u % (w + 1);
        int vi = v / (w + 1), vj = v % (w + 1);
        unordered_set<int> st;
        for (int i = -1; i <= 0; ++i) {
          for (int j = -1; j <= 0; ++j) {
            if (vi + i >= 0 && vi + i < h && vj + j >= 0 && vj + j < w && arr[vi + i][vj + j] == '#') {
              st.insert((vi + i) * w + vj + j);
            }
          }
        }
        for (int i = -1; i <= 0; ++i) {
          for (int j = -1; j <= 0; ++j) {
            if (ui + i >= 0 && ui + i < h && uj + j >= 0 && uj + j < w && arr[ui + i][uj + j] == '#') {
              st.erase((ui + i) * w + uj + j);
            }
          }
        }
        help[u][d] = vector<int>(st.begin(), st.end());
      }
    }
  }

  for (int i = 0; i <= h; ++i) {
    for (int j = 0; j <= w; ++j) {
      int s = i * (w + 1) + j;
      for (int t = 0; t < (h + 1) * (w + 1); ++t) {
        simple_dist[s][t] = INF;
      }
      simple_dist[s][s] = 0;
      set<array<int, 2>> st;
      st.insert({0, s});
      while (!st.empty()) {
        int v = (*st.begin())[1];
        st.erase(st.begin());
        int i = v / (w + 1), j = v % (w + 1);
        for (int d = 0; d < 4; ++d) {
          int i1 = i + dx[d], j1 = j + dy[d];
          if (i1 < 0 || i1 > h || j1 < 0 || j1 > w) continue;
          int u = i1 * (w + 1) + j1;
          int c = get_w(v, d);
          /**if (s == 0) {
            cerr << v << " " << u << " " << c << endl;
          }*/
          if (simple_dist[s][u] > simple_dist[s][v] + c) {
            st.erase({simple_dist[s][u], u});
            simple_dist[s][u] = simple_dist[s][v] + c;
            st.insert({simple_dist[s][u], u});
          }
        }
      }
    }
  }

  /// cout << (clock() - start) * 1.0 / CLOCKS_PER_SEC << endl;

  int no = w * h;

  for (int i = 0; i < (h + 1) * (w + 1); ++i) {
    for (int house = 0; house <= no; ++house) {
      for (int dir = 0; dir < 4; ++dir) {
        d[i][house][dir] = INF;
      }
    }
  }

  d[0][no][0] = (arr[0][0] == '#');
  /// set<array<int, 4>> st;
  /// st.insert({d[0][no][0], 0, no, 0});
  array<vector<array<int, 3>>, 3> q;
  int qsz = 0;

  auto add = [&](int v, int mem, int dir) {
    q[d[v][mem][dir] % 3].push_back({v, mem, dir});
    ++qsz;
  };

  int ptr = d[0][no][0];
  add(0, no, 0);

  while (qsz > 0) {
    /**auto elem = *st.begin();
    st.erase(st.begin());*/
    while (q[ptr].empty()) {
      ptr = (ptr + 1) % 3;
    }
    auto elem = q[ptr].back();
    q[ptr].pop_back();
    --qsz;
    int pt = elem[0], mem = elem[1], dir = elem[2];
    if (used[pt][mem][dir]) continue;
    used[pt][mem][dir] = true;
    /// cerr << pt << " " << mem << " " << dir << "->" << elem[0] << endl;
    int i = pt / (w + 1), j = pt % (w + 1);
    /// simple step:
    for (int dr = 0; dr < 4; ++dr) {
      int i1 = i + dx[dr], j1 = j + dy[dr];
      if (i1 < 0 || i1 > h || j1 < 0 || j1 > w) continue;
      int u = i1 * (w + 1) + j1;
      int c = get_w(pt, dr, mem);
      if (d[u][mem][dir] > d[pt][mem][dir] + c) {
        /// st.erase({d[u][mem][dir], u, mem, dir});
        d[u][mem][dir] = d[pt][mem][dir] + c;
        /// st.insert({d[u][mem][dir], u, mem, dir});
        add(u, mem, dir);
      }
    }
    /// load new house instead
    for (int di = -1; di <= 0; ++di) {
      for (int dj = -1; dj <= 0; ++dj) {
        int hi = i + di, hj = j + dj;
        if (hi < 0 || hi >= h || hj < 0 || hj >= w || arr[hi][hj] != '#') continue;
        /// just forget about old house
        int mem1 = hi * w + hj;
        int dir1 = (di + 1) * 2 + (dj + 1);
        if (d[pt][mem1][dir1] > d[pt][mem][dir]) {
          /// st.erase({d[pt][mem1][dir1], pt, mem1, dir1});
          d[pt][mem1][dir1] = d[pt][mem][dir];
          /// st.insert({d[pt][mem1][dir1], pt, mem1, dir1});
          add(pt, mem1, dir1);
        }
        /// teleport into the old house-point
        if (mem == no) continue;
        int memi = mem / w, memj = mem % w;
        bool is_neigh = true;
        if (memi > i || memi < i - 1 || memj > j || memj < j - 1) {
          is_neigh = false;
        }
        if (is_neigh) continue;
        memi += dir / 2;
        memj += (dir % 2);
        int hp = memi * (w + 1) + memj;
        int c = simple_dist[pt][hp] - 1;
        if (c != 0) continue;
        /// cerr << "c: " << c << endl;
        if (d[hp][mem1][dir1] > d[pt][mem][dir] + c) {
          /// st.erase({d[hp][mem1][dir1], hp, mem1, dir1});
          d[hp][mem1][dir1] = d[pt][mem][dir] + c;
          /// st.insert({d[hp][mem1][dir1], hp, mem1, dir1});
          add(hp, mem1, dir1);
        }
      }
    }
  }

  int ans = INF;
  for (int x = 0; x <= h * w; ++x) {
    for (int dir = 0; dir < 4; ++dir) {
      /**if (d[(h + 1) * (w + 1) - 1][x][dir] == 0) {
        cerr << x << " " << dir << endl;
      }*/
      ans = min(ans, d[(h + 1) * (w + 1) - 1][x][dir]);
    }
  }
  cout << ans << "\n";
  /// cerr << simple_dist[0][(w + 1) * (h + 1) - 1] << endl;

  return 0;
}