#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// sz: size of the matching
// mate[u]: matching mate of u or -1
// need[u]: every max matching contains u? (call run(true))
struct MaxMatching {
  int n, sz;
  vector<vector<int>> graph;
  vector<int> mate, need;
  MaxMatching() {}
  MaxMatching(int n_) : n(n_), graph(n_) {}
  void ae(int u, int v) {
    assert(0 <= u); assert(u < n);
    assert(0 <= v); assert(v < n);
    if (u != v) {
      graph[u].push_back(v);
      graph[v].push_back(u);
    }
  }

  vector<int> ts, ps;
  vector<pair<int, int>> fs;
  int root(int u) {
    return (ts[u] != sz || !~ps[u]) ? u : (ps[u] = root(ps[u]));
  }
  void rematch(int u, int v) {
    const int w = mate[u];
    mate[u] = v;
    if (~w && mate[w] == u) {
      if (~fs[u].second) {
        rematch(fs[u].first, fs[u].second);
        rematch(fs[u].second, fs[u].first);
      } else {
        mate[w] = fs[u].first;
        rematch(fs[u].first, w);
      }
    }
  }
  int augment(int src) {
    std::queue<int> que;
    ts[src] = sz;
    ps[src] = -1;
    fs[src] = make_pair(-1, -1);
    que.push(src);
    for (; !que.empty();) {
      int u = que.front();
      que.pop();
      for (const int v : graph[u]) if (v != src) {
        if (mate[v] == -1) {
          mate[v] = u;
          rematch(u, v);
          return 1;
        }
        if (ts[v] == sz) {
          int x = root(u), y = root(v), z = src;
          if (x == y) continue;
          for (; x != src || y != src; x = root(fs[mate[x]].first)) {
            if (y != src) swap(x, y);
            if (fs[x].first == u && fs[x].second == v) {
              z = x;
              break;
            }
            fs[x] = make_pair(u, v);
          }
          for (const int r : {root(u), root(v)}) {
            for (int w = r; w != z; w = root(fs[mate[w]].first)) {
              ts[w] = sz;
              ps[w] = z;
              que.push(w);
            }
          }
        } else if (ts[mate[v]] != sz) {
          fs[v] = make_pair(-1, -1);
          ts[mate[v]] = sz;
          ps[mate[v]] = v;
          fs[mate[v]] = make_pair(u, -1);
          que.push(mate[v]);
        }
      }
    }
    return 0;
  }
  void run(bool buildNeed = false) {
    sz = 0;
    mate.assign(n, -1);
    ts.assign(n, -1);
    ps.assign(n, -1);
    fs.assign(n, make_pair(-1, -1));
    for (int u = 0; u < n; ++u) if (!~mate[u]) sz += augment(u);
    if (buildNeed) {
      for (int u = 0; u < n; ++u) if (!~mate[u]) augment(u);
      need.resize(n);
      for (int u = 0; u < n; ++u) need[u] = (~mate[u] && ts[u] != sz) ? 1 : 0;
    }
  }
};

////////////////////////////////////////////////////////////////////////////////


int M, N;
char A[110][110];

int main() {
  for (; ~scanf("%d%d", &M, &N); ) {
    for (int x = 0; x < M; ++x) {
      scanf("%s", A[x]);
    }
    
    MaxMatching mm(M * N);
    for (int x = 0; x < M; ++x) for (int y = 0; y < N; ++y) if (A[x][y] == '.') {
      if (x + 1 < M && A[x + 1][y] == '.') mm.ae(x * N + y, (x + 1) * N + y);
      if (y + 1 < N && A[x][y + 1] == '.') mm.ae(x * N + y, x * N + (y + 1));
    }
    mm.run(true);
// cerr<<"need = "<<mm.need<<endl;
    int ans = 0;
    for (int x = 0; x < M; ++x) for (int y = 0; y < N; ++y) if (A[x][y] == '.') {
      if (!mm.need[x * N + y]) ++ans;
    }
    printf("%d\n", ans);
  }
  return 0;
}