#include<iostream>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
const int inf = 1e9;
const int N = 50;
const int L = N*N + 2;
queue <int> q;
struct Dinic{
    int cap[L][L];
    int flow[L][L];
    vector <int> edges[L];
    int dist[L];
    int ptr[L];
    int n;
    int s,t;
    void init(int sz){
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                cap[i][j] = flow[i][j] = 0;
            }
            edges[i].clear();
        }
        n = sz;
    }
    void addedge(int u,int w,int c){
        //cout<<u<<' '<<w<<' '<<c<<'\n';
        cap[u][w]+=c;
        edges[u].push_back(w);
        edges[w].push_back(u);
    }
    void bfs(){
        for(int i = 0;i < n;i++){
            dist[i] = -1;
        }
        q.push(s);
        dist[s] = 0;
        while(!q.empty()){
            int x = q.front();
            q.pop();
            for(auto i:edges[x]){
                if(flow[x][i] == cap[x][i] || dist[i] != -1)continue;
                q.push(i);
                dist[i] = dist[x] + 1;
            }
        }
    }
    int dfs(int node,int nr){
        if(node == t){
            return nr;
        }
        while(ptr[node] < (int)edges[node].size()){
            int id = edges[node][ptr[node]];
            ptr[node]++;
            if(dist[id] == dist[node] + 1 && flow[node][id] != cap[node][id]){
                ///can push into here
                int x = dfs(id,min(cap[node][id] - flow[node][id],nr));
                if(x == 0)continue;
                flow[node][id]+=x;
                flow[id][node]-=x;
                return x;
            }
        }
        return 0;
    }
    int maxflow(int st,int en){
        s = st;
        t = en;
        int r = 0;
        while(1){
            bfs();
            if(dist[t] == -1)break;
            for(int i = 0;i < n;i++)ptr[i] = 0;
            while(1){
                int x = dfs(s,inf);
                r+=x;
                if(x == 0)break;
            }
        }
        for(int i = 0;i < n;i++){
            for(auto j:edges[i]){
                flow[i][j] = 0;
            }
        }
        return r;
    }
};
Dinic flow;
int d[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
int n,m;
char v[N][N];
int vis[N][N];
int id[N][N];
vector <pair<int,int>> e;
vector <int> source;
vector <int> sink;
int sz = 0;
bool inbound(int x,int y){
    return 0 <= x && x < n && 0 <= y && y < m;
}
void dfs(int x,int y){
    vis[x][y] = 1;
    id[x][y] = sz++;
    if((x + y)%2 == 0){
        source.push_back(id[x][y]);
    }else{
        sink.push_back(id[x][y]);
    }
    for(int i = 0;i < 4;i++){
        int nx = x + d[i][0];
        int ny = y + d[i][1];
        if(inbound(nx,ny) && v[nx][ny] == '.'){
            if(!vis[nx][ny]){
                dfs(nx,ny);
            }
            if(id[x][y] < id[nx][ny]){
                if((x + y)%2 == 0){
                    e.push_back({id[x][y],id[nx][ny]});
                }else{
                    e.push_back({id[nx][ny],id[x][y]});
                }
            }
        }
    }
}
int gb = -1;
int ans = 0;
void dfs2(int x,int y){
    int nr = id[x][y];
    if((x + y)%2 == 0){
        flow.cap[0][nr + 1]--;
    }else{
        flow.cap[nr + 1][sz + 1]--;
    }
    if(flow.maxflow(0,sz + 1) == gb){
        ans++;
    }
    if((x + y)%2 == 0){
        flow.cap[0][nr + 1]++;
    }else{
        flow.cap[nr + 1][sz + 1]++;
    }
    vis[x][y] = 2;
    for(int i = 0;i < 4;i++){
        int nx = x + d[i][0];
        int ny = y + d[i][1];
        if(inbound(nx,ny) && v[nx][ny] == '.'){
            if(vis[nx][ny] == 1){
                dfs2(nx,ny);
            }
        }
    }
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>n>>m;
    int cnt = 0;
    for(int i = 0;i < n;i++){
        for(int j = 0;j < m;j++){
            cin>>v[i][j];
            if(v[i][j] == '#')cnt++;
        }
    }
    for(int i = 0;i < n;i++){
        for(int j = 0;j < m;j++){
            if(v[i][j] == '.' && vis[i][j] == 0){
                sz = 0;
                e.clear();
                source.clear();
                sink.clear();
                dfs(i, j);
                flow.init(sz + 2);
                for(auto i:source){
                    flow.addedge(0,i + 1,1);
                }
                for(auto i:sink){
                    flow.addedge(i + 1,sz + 1,1);
                }
                for(auto i:e){
                    flow.addedge(i.first + 1,i.second + 1,1);
                }
                gb = flow.maxflow(0,sz + 1);
                dfs2(i, j);
            }
        }
    }
    cout<<ans;
    return 0;
}