// https://www.youtube.com/watch?v=CrymicX875M
// Angel of mercy
// How did you move me
// Why am I on my feet again

#ifndef ONLINE_JUDGE
#include "templates/debug.hpp"
#else
#define debug(...)
#endif

#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using u64 = uint64_t;

// O(n^2 sqrt(m))
template <typename ANS_TYPE> struct MaxFlowHLPP {
    struct Edge {
        int to;
        ANS_TYPE c;
        int rev;
        Edge(int to, ANS_TYPE c, int rev) : to(to), c(c), rev(rev) {}
    };

    int n, s, t;
    int maxh{}, maxgaph{}, workcnt{};
    vector<vector<Edge>> adj;
    vector<ANS_TYPE> ov;
    vector<int> h;
    vector<int> cur;
    vector<int> ovList, ovNxt;
    vector<int> gap, gapPrv, gapNxt;

    MaxFlowHLPP(int n)
        : n(n), adj(n), ov(n), h(n), cur(n), ovList(n + 1, -1),
          ovNxt(n + 1, -1), gap(n + 1, -1), gapPrv(n + 1, -1),
          gapNxt(n + 1, -1) {}

    void addEdge(int u, int v, ANS_TYPE c) {
        adj[u].emplace_back(v, c, adj[v].size());
        adj[v].emplace_back(u, 0, adj[u].size() - 1);
    }

    ANS_TYPE getMaxFlow(int qs, int qt) {
        s = qs, t = qt;
        globalRelabel();
        for (auto &e : adj[s]) if (e.c) {
            pushFlow(s, e, e.c);
            maxh = max(maxh, h[e.to]);
        }
        for (; maxh >= 0; --maxh) {
            while (~ovList[maxh]) {
                int x = ovList[maxh];
                ovList[maxh] = ovNxt[x];
                discharge(x);
                if (workcnt > (n << 2)) globalRelabel();
            }
        }
        return ov[t];
    }

  private:
    void discharge(int x) {
        int nh = n, sz = adj[x].size();
        for (int i = cur[x]; i < sz; ++i) {
            auto &e = adj[x][i];
            if (e.c > 0) {
                if (h[x] == h[e.to] + 1) {
                    pushFlow(x, e, min(ov[x], e.c));
                    if (ov[x] == 0) {
                        cur[x] = i;
                        return;
                    }
                } else nh = min(nh, h[e.to] + 1);
            }
        }
        for (int i = 0; i < cur[x]; ++i) {
            auto &e = adj[x][i];
            if (e.c > 0) {
                nh = min(nh, h[e.to] + 1);
            }
        }
        cur[x] = 0;
        ++workcnt;
        if (~gapNxt[gap[h[x]]])
            setHeight(x, nh);
        else {
            int oldh = h[x];
            for (int i = oldh; i <= maxgaph; ++i) {
                for (int j = gap[i]; ~j; j = gapNxt[j]) h[j] = n;
                gap[i] = -1;
            }
            maxgaph = oldh - 1;
        }
    }

    void globalRelabel() {
        workcnt = maxh = maxgaph = 0;
        fill(h.begin(), h.end(), n);
        h[t] = 0;
        fill(gapPrv.begin(), gapPrv.end(), -1);
        fill(gapNxt.begin(), gapNxt.end(), -1);
        fill(gap.begin(), gap.end(), -1);
        fill(ovList.begin(), ovList.end(), -1);
        fill(ovNxt.begin(), ovNxt.end(), -1);
        fill(cur.begin(), cur.end(), 0);
        queue<int> que;
        que.push(t);
        int x;
        while (!que.empty()) {
            x = que.front();
            que.pop();
            for (auto &e : adj[x]) {
                if (h[e.to] == n && e.to != s && adj[e.to][e.rev].c > 0) {
                    setHeight(e.to, h[x] + 1);
                    que.push(e.to);
                }
            }
        }
    }

    void setHeight(int x, int newh) {
        if (~gapPrv[x]) {
            if (gapPrv[x] == x) {
                gapPrv[gapNxt[x]] = gapNxt[x];
                gap[h[x]] = gapNxt[x];
            } else {
                gapNxt[gapPrv[x]] = gapNxt[x];
                if (~gapNxt[x]) gapPrv[gapNxt[x]] = gapPrv[x];
            }
        }
        if ((h[x] = newh) >= n) return; // ignore the case of h >= n
        maxgaph = max(maxgaph, h[x]);
        if (ov[x] > 0) {
            maxh = max(maxh, h[x]);
            ovNxt[x] = ovList[h[x]];
            ovList[h[x]] = x;
        }
        if (~(gapNxt[x] = gap[h[x]])) gapPrv[gapNxt[x]] = x;
        gap[h[x]] = gapPrv[x] = x;
    }

    void pushFlow(int from, Edge &e, ANS_TYPE flow) {
        if (!ov[e.to] && e.to != t) {
            ovNxt[e.to] = ovList[h[e.to]];
            ovList[h[e.to]] = e.to;
        }
        e.c -= flow;
        adj[e.to][e.rev].c += flow;
        ov[from] -= flow;
        ov[e.to] += flow;
    }
};


struct MaxFlow {
    struct Edge {
        int to, cap, nxt;
    };

    int n, cnt = 0;
    vector<int> head;
    vector<Edge> es;

    MaxFlow(int n) : n(n), head(n, -1), dep(n) {}

    void addEdge(int u, int v, int cap) {
        es.push_back({v, cap, head[u]});
        head[u] = cnt++;
        es.push_back({u, 0, head[v]});
        head[v] = cnt++;
    }

    int s, t;
    vector<int> dep, cur;
    bool bfs() {
        fill(dep.begin(), dep.end(), -1);
        queue<int> q;
        dep[s] = 0; q.push(s);
        while (!q.empty()) {
            int u = q.front(); q.pop();
            for (int i = head[u]; ~i; i = es[i].nxt) {
                int v = es[i].to;
                if (dep[v] == -1 && es[i].cap) {
                    dep[v] = dep[u] + 1;
                    q.push(v);
                }
            }
        }
        return ~dep[t];
    }

    int dfs(int u, int flow) {
        if (u == t || !flow) return flow;
        int rmn = flow;
        for (int &i = cur[u]; ~i; i = es[i].nxt) {
            int v = es[i].to;
            if (dep[v] == dep[u] + 1) {
                int d = dfs(v, min(rmn, es[i].cap));
                rmn -= d;
                es[i].cap -= d;
                es[i ^ 1].cap += d;
                if (!rmn) return flow;
            }
        }
        return flow - rmn;
    }

    int dinic(int qs, int qt) {
        int ans = 0; s = qs, t = qt;
        while (bfs()) {
            cur = head;
            ans += dfs(s, INT_MAX);
        }
        return ans;
    }
};

void solve() {
    int n, m; cin >> n >> m;
    vector<string> s(n);
    for (int i = 0; i < n; i++) cin >> s[i];
    vector<pair<int, int>> pos;
    vector<vector<int>> id(n, vector<int>(m, -1));
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i][j] == '#') {
                pos.emplace_back(i, j);
                id[i][j] = cnt++;
            }
        }
    }
    MaxFlowHLPP<int> mf(2 * cnt + 2);
    constexpr int INF = 65536;
    const int S = 2 * cnt, T = 2 * cnt + 1;
    for (int i = 0; i < cnt; i++) {
        auto [x, y] = pos[i];
        mf.addEdge(2 * i, 2 * i + 1, 1);
        if (x == 0 || y == m - 1) {
            mf.addEdge(2 * i + 1, T, INF);
        }
        if (x == n - 1 || y == 0) {
            mf.addEdge(S, 2 * i, INF);
        }
        for (int dx = -2; dx <= 2; dx++) {
            for (int dy = -2; dy <= 2; dy++) {
                int nx = x + dx, ny = y + dy;
                bool valid = 0 <= nx && nx < n && 0 <= ny && ny < m;
                if (valid && s[nx][ny] == '#') {
                    int j = id[nx][ny];
                    mf.addEdge(2 * i + 1, 2 * j, INF);
                }
            }
        }
    }
    cout << mf.getMaxFlow(S, T) << '\n';
}
#undef int

// Make bold hypotheses and verify carefully
int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    };
}