//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")

#include <bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}
template<typename T>
bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#ifdef KIVI
#define DEBUG for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define DEBUG while (false)
#define LOG(...)
#endif

const int max_n = 51, inf = 1000111222;

struct max_flow {

    struct edge {
        int to, c;
        edge () : to(0), c(0) {}
        edge (int to, int c) : to(to), c(c) {}
    };

    max_flow (int n) : n(n) {
        g.resize(n);
    }

    vector <vector <int> > g;
    vector <edge> e;

    inline void add_edge (int a, int b, int c) {
        g[a].pb(len(e));
        e.pb(edge(b, c));
        g[b].pb(len(e));
        e.pb(edge(a, 0));
    }
    vector <int> d;

    int n, s, t;

    inline bool bfs (int mn, int bl) {
        d.assign(n, inf);
        queue <int> q;
        q.push(s);
        d[s] = 0;
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (int id : g[v]) {
                int len = e[id].c, to = e[id].to;
                if (len >= mn && d[to] == inf && to != bl) {
                    d[to] = d[v] + 1;
                    q.push(to);
                }
            }
        }
        return d[t] != inf;
    }

    vector <int> pr;
    inline bool dfs (int v, int mn, int bl) {
        if (!mn) return false;
        if (v == t) return true;
        for (; pr[v] < len(g[v]); pr[v]++) {
            int id = g[v][pr[v]];
            int to = e[id].to, len = e[id].c;
            if (d[to] == d[v] + 1 && len >= mn && to != bl) {
                if (dfs(to, mn, bl)) {
                    e[id].c -= mn;
                    e[id ^ 1].c += mn;
                    return true;
                }
            }
        }
        return false;
    }

    inline ll dinic (int bl = -1) {
        ll flow = 0;
        for (int lim = 1; lim > 0; ) {
            if (!bfs(lim, bl)) {
                lim /= 2;
                continue;
            }
            pr.assign(n, 0);
            while (dfs(s, lim, bl)) {
                flow += lim;
            }
        }
        return flow;
    }

    vector <int> h1;

    inline void dfs1 (int v) {
        h1[v] = true;
        for (int id : g[v]) {
            if (e[id].c > 0 && !h1[e[id].to]) {
                dfs1(e[id].to);
            }
        }
    }

    inline void min_cut () {
        h1.assign(n, false);
        dfs1(s);
        for (int i = 0; i < n; i++) {
            if (!h1[i]) {
                continue;
            }
            for (int id : g[i]) {
                int to = e[id].to;
                if (!h1[to]) {
                    /// min cut edge

                }
            }
        }
    }
};

string s[max_n];

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

inline int solve (int n, int m, int p) {
    int ans = 0;
    max_flow t(n * m + 2);
    auto get_id = [&] (int i, int j) {
        return i * m + j;
    };
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i][j] == '#') {
                continue;
            }
            if (((i ^ j) & 1) == p) {
                t.add_edge(n * m, get_id(i, j), 1);
                for (int d = 0; d < 4; d++) {
                    int tox = i + dx[d];
                    int toy = j + dy[d];
                    if (tox < 0 || toy < 0 || tox >= n || toy >= m || s[tox][toy] == '#') {
                        continue;
                    }
                    t.add_edge(get_id(i, j), get_id(tox, toy), 1);
                }
            }
            else {
                t.add_edge(get_id(i, j), n * m + 1, 1);
            }
        }
    }
    t.s = n * m;
    t.t = n * m + 1;
    int res = t.dinic();
    LOG(res);
    auto gg = t;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i][j] == '#') {
                continue;
            }
            if (((i ^ j) & 1) == p) {
                t.s = n * m + 1;
                t.t = get_id(i, j);
                if (t.dinic()) {
                    LOG("here", i, j);
                    swap(t.s, t.t);
                    t.s = n * m;
                    if (t.dinic(get_id(i, j))) {
                        ++ans;
                    }
                }
                else {
                    ++ans;
                }
                t = gg;
            }
        }
    }
    return ans;
}

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> s[i];
    }
    int ans = solve(n, m, 0) + solve(n, m, 1);
    cout << ans << '\n';
}