#include<bits/stdc++.h>
using namespace std;
#define all(a) begin(a),end(a)
#define sz(a) int(size(a))
#define rep(i,a,b) for(int i=(a);i<(b);++i)
using vi = vector<int>;
using ll = long long int;

const ll MAXA = ll(1e6);

bool dfs(int a, int L, vector<vi>& g, vi& btoa, vi &A, vi &B) {
    if(A[a] != L) return 0;
    A[a] = -1;
    for(int b : g[a]) if(B[b] == L+1) {
        B[b] = 0;
        if(btoa[b] == -1 || dfs(btoa[b], L+1, g, btoa, A, B))
            return btoa[b] = a, 1;
    }
    return 0;
}

int hopcroftKarp(vector<vi>& g, vi& btoa) {
    int res = 0;
    vi A(g.size()), B(btoa.size()), cur, next;
    for(;;) {
        fill(all(A), 0);
        fill(all(B), 0);
        cur.clear();
        for(int a : btoa) if(a != -1) A[a] = -1;
        rep(a,0,sz(g)) if(A[a] == 0) cur.push_back(a);
        for(int lay = 1;; lay++) {
            bool islast = 0;
            next.clear();
            for(int a : cur) for(int b : g[a]) {
                if(btoa[b] == -1) {
                    B[b] = lay;
                    islast = 1;
                }
                else if(btoa[b] != a && !B[b]) {
                    B[b] = lay;
                    next.push_back(btoa[b]);
                }
            }
            if(islast) break;
            if(next.empty()) return res;
            for(int a : next) A[a] = lay;
            cur.swap(next);
        }
        rep(a,0,sz(g))
            res += dfs(a, 0, g, btoa, A, B);
    }
}

vi leftIDs, rightIDs;
int count(int side, int id, vector<vi>& g, vi& btoa, vector<vi>& vis) {
    vis[side][id] = true;
    if(side) {
        if(!vis[1-side][btoa[id]]) return count(1-side, btoa[id], g, btoa, vis);
        return 0;
    }
    int res = 1;
    for(int to : g[id]) if(btoa[to] != id and !vis[1-side][to])
        res += count(1-side, to, g, btoa, vis);
    return res;
}

void solve(int tc) {
    int N, M; cin >> N >> M;
    vector<string> grid(N);
    for(string &s : grid) cin >> s;

    vector<vi> id(N, vi(M));
    vector<vi> leftAdj(N*M);
    for(int r = 0; r < N; r++)
        for(int c = 0; c < M; c++) {
            if(grid[r][c] == '#') continue;
            if((r ^ c) & 1) {
                // right side cell
                id[r][c] = sz(rightIDs);
                rightIDs.push_back(M*r + c);
                if(r and grid[r-1][c] != '#') {
                    // up direction
                    leftAdj[id[r-1][c]].push_back(id[r][c]);
                }
                if(c and grid[r][c-1] != '#') {
                    // left direction
                    leftAdj[id[r][c-1]].push_back(id[r][c]);
                }
            } else {
                // left side cell
                id[r][c] = sz(leftIDs);
                leftIDs.push_back(M*r + c);
                if(r and grid[r-1][c] != '#') {
                    // up direction
                    leftAdj[id[r][c]].push_back(id[r-1][c]);
                }
                if(c and grid[r][c-1] != '#') {
                    // left direction
                    leftAdj[id[r][c]].push_back(id[r][c-1]);
                }
            }
        }
    
    assert(sz(leftIDs) == sz(rightIDs));

    int K = sz(leftIDs);
    ll sames = ll(K) * (K-1);
    if(sames >= MAXA) {
        cout << MAXA << '\n';
        return;
    }

    // otherwise, it's small enough to build and do a matching
    leftAdj.erase(begin(leftAdj) + K);
    vi btoa(K, -1);
    assert(hopcroftKarp(leftAdj, btoa) == K);

    vector<vi> vis(2, vi(K));
    ll addl = 0;
    for(int ri = 0; ri < K; ri++) {
        vis[0].assign(K, 0), vis[1].assign(K, 0);
        addl += count(1, ri, leftAdj, btoa, vis);
    }
    
    cout << min(sames + K*K - addl, MAXA) << '\n';

}

int main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int t = 1;
    // cin >> t;
    for(int i = 1; i <= t; i++) solve(i);
    cout.flush(); return 0;
}