#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;

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

template<class T>
struct PQ {
    std::queue<T> q[3];
    
    T pop() {
        int i = -1;
        for (int j = 0; j <= 2; j++) {
            if (!q[j].empty()) {
                if (i == -1 || q[j].front() < q[i].front()) {
                    i = j;
                }
            }
        }
        assert(i != -1);
        auto res = q[i].front();
        q[i].pop();
        return res;
    }
    
    void push(const T &a, int c) {
        q[c].push(a);
    }
    
    bool empty() {
        for (int i = 0; i <= 2; i++) {
            if (!q[i].empty()) {
                return false;
            }
        }
        return true;
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m;
    std::cin >> n >> m;
    
    std::vector<std::string> s(n);
    for (int i = 0; i < n; i++) {
        std::cin >> s[i];
    }
    
    std::vector S(n, std::vector<int>(m));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            S[i][j] = (s[i][j] == '#');
        }
    }
    
    std::vector dp(n + 1, std::vector(m + 1, std::vector(n + 1, std::vector(m + 1, -1))));
    
    std::vector cost(n + 1, std::vector(m + 1, std::array<int, 4>{}));
    
    for (int x = 0; x <= n; x++) {
        for (int y = 0; y <= m; y++) {
            for (int dir = 0; dir < 4; dir++) {
                int nx = x + dx[dir];
                int ny = y + dy[dir];
                if (nx < 0 || nx > n || ny < 0 || ny > m) {
                    continue;
                }
                int lx = -1, rx = 0, ly = -1, ry = 0;
                if (dir == 0) {
                    lx++;
                } else if (dir == 1) {
                    ly++;
                } else if (dir == 2) {
                    rx--;
                } else {
                    ry--;
                }
                for (int dx = lx; dx <= rx; dx++) {
                    for (int dy = ly; dy <= ry; dy++) {
                        int ax = nx + dx;
                        int ay = ny + dy;
                        if (0 <= ax && ax < n && 0 <= ay && ay < m) {
                            cost[x][y][dir] += S[ax][ay];
                        }
                    }
                }
            }
        }
    }
    
    std::vector dis(n + 1, std::vector(m + 1, std::vector(n + 1, std::vector(m + 1, -1))));
    for (int sx = 0; sx <= n; sx++) {
        for (int sy = 0; sy <= m; sy++) {
            PQ<std::array<int, 3>> pq;
            pq.push({0, sx, sy}, 0);
            while (!pq.empty()) {
                auto [d, x, y] = pq.pop();
                
                if (dis[sx][sy][x][y] != -1) {
                    continue;
                }
                dis[sx][sy][x][y] = d;
                
                for (int dir = 0; dir < 4; dir++) {
                    int nx = x + dx[dir];
                    int ny = y + dy[dir];
                    if (nx < 0 || nx > n || ny < 0 || ny > m) {
                        continue;
                    }
                    pq.push({d + cost[x][y][dir], nx, ny}, cost[x][y][dir]);
                }
            }
        }
    }
    
    PQ<std::array<int, 5>> pq;
    pq.push({s[0][0] == '.' ? 0 : 1, 0, 0, 0, 0}, 0);
    
    int ans = 1E9;
    while (!pq.empty()) {
        auto [d, x, y, a, b] = pq.pop();
        
        if (dp[x][y][a][b] != -1) {
            continue;
        }
        
        dp[x][y][a][b] = d;
        
        if (x == n && y == m) {
            ans = std::min(ans, d);
        }
        
        for (int dir = 0; dir < 4; dir++) {
            int nx = x + dx[dir];
            int ny = y + dy[dir];
            if (nx < 0 || nx > n || ny < 0 || ny > m) {
                continue;
            }
            pq.push({d + cost[x][y][dir], nx, ny, a, b}, cost[x][y][dir]);
            pq.push({d + cost[x][y][dir], nx, ny, nx, ny}, cost[x][y][dir]);
        }
        
        for (int dx = -1; dx <= 1; dx += 2) {
            for (int dy = -1; dy <= 1; dy += 2) {
                int nx = a + dx;
                int ny = b + dy;
                if (nx < 0 || nx > n || ny < 0 || ny > m) {
                    continue;
                }
                int ax = std::min(a, nx);
                int ay = std::min(b, ny);
                int c = dis[x][y][nx][ny];
                if (ax < x - 1 || ax > x || ay < y - 1 || ay > y) {
                    c -= S[ax][ay];
                }
                assert(c >= 0);
                if (c <= 2) {
                    pq.push({d + c, nx, ny, x, y}, c);
                }
            }
        }
    }
    
    std::cout << ans << "\n";
    
    return 0;
}