//#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 = -1, inf = 1000111222;

namespace max_flow {
    const int max_n = 1e5;
    struct ed {
        int to, f;
    };

    vector <ed> e;
    vector <int> edge[max_n];

    inline void add_edge (int u, int v, int f) {
        edge[u].pb(len(e));
        e.pb(ed{v, f});
        edge[v].pb(len(e));
        e.pb(ed{u, 0});
    }

    inline void add_bidirectional_edge (int u, int v, int f) {
        add_edge(u,v,f);
        add_edge(v,u,f);
    }

    int d[max_n], p[max_n];
    queue <int> q;

    inline bool bfs (int n, int s, int t) {
        for (int i = 0; i < n; i++) {
            d[i] = inf;
            p[i] = 0;
        }
        q.push(s);
        d[s] = 0;
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (int id : edge[v]) {
                if (e[id].f > 0 && d[e[id].to] == inf) {
                    d[e[id].to] = d[v] + 1;
                    q.push(e[id].to);
                }
            }
        }
        return d[t] != inf;
    }

    inline int dfs (int v, int s, int flow = inf) {
        if (!flow) {
            return 0;
        }
        if (v == s) {
            return flow;
        }
        for (; p[v] < len(edge[v]); ) {
            int id = edge[v][p[v]];
            int to = e[id].to;
            if (d[to] == d[v] + 1 && e[id].f > 0) {
                int res = dfs(to, s, min(flow, e[id].f));
                if (res) {
                    e[id].f -= res;
                    e[id ^ 1].f += res;
                    return res;
                }
            }
            ++p[v];
        }
        return 0;
    }


    inline ll solve (int n, int s, int t) {
        ll ans = 0;
        while (bfs(n, s, t)) {
            int f = dfs(s, t);
            while (f) {
                ans += f;
                f = dfs(s, t);
            }
        }
        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,a,b;
    cin>>n>>m>>a>>b;
    vector<string> s(n);
    for (int i=0;i<n;i++){
        cin>>s[i];
    }
    const int S=n*m,T=n*m+1,N=n*m+2;
    for (int i=0;i<n;i++){
        for (int j=0;j<m;j++){
            if (s[i][j]=='#'){
                max_flow::add_bidirectional_edge(i*m+j,T,b);
            }
            else{
                max_flow::add_bidirectional_edge(i*m+j,S,b);
            }

            if (i+1<n){
                max_flow::add_bidirectional_edge(i*m+j,(i+1)*m+j,a);
            }
            if (j+1<m){
                max_flow::add_bidirectional_edge(i*m+j,i*m+(j+1),a);
            }
        }
    }
    cout<<max_flow::solve(N,S,T)<<"\n";
}