#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int V = 1100;
const int E = 1010000;

template <typename T>
struct FlowGraph
{
    int s, t, vtot;
    int head[V], etot;
    int dis[V], cur[V];
    struct edge
    {
        int v, nxt;
        T f;
    } e[E * 2];
    void add(int u, int v, T f)
    {
        e[etot] = {v, head[u], f};
        head[u] = etot++;
        e[etot] = {u, head[v], 0};
        head[v] = etot++;
    }

    bool bfs()
    {
        for (int i = 1; i <= vtot; i++)
        {
            dis[i] = 0;
            cur[i] = head[i];
        }
        queue<int> q;
        q.push(s);
        dis[s] = 1;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            for (int i = head[u]; ~i; i = e[i].nxt)
            {
                if (e[i].f && !dis[e[i].v])
                {
                    int v = e[i].v;
                    dis[v] = dis[u] + 1;
                    if (v == t)
                        return true;
                    q.push(v);
                }
            }
        }
        return false;
    }

    T dfs(int u, T m)
    {
        if (u == t)
            return m;
        T flow = 0;
        for (int i = cur[u]; ~i; cur[u] = i = e[i].nxt)
            if (e[i].f && dis[e[i].v] == dis[u] + 1)
            {
                T f = dfs(e[i].v, min(m, e[i].f));
                e[i].f -= f;
                e[i ^ 1].f += f;
                m -= f;
                flow += f;
                if (!m)
                    break;
            }
        if (!flow)
            dis[u] = -1;
        return flow;
    }
    T dinic()
    {
        T flow = 0;
        while (bfs())
            flow += dfs(s, numeric_limits<T>::max());
        return flow;
    }
    void init(int s_, int t_, int vtot_)
    {
        s = s_;
        t = t_;
        vtot = vtot_;
        etot = 0;
        for (int i = 1; i <= vtot; i++)
            head[i] = -1;
    }
};
FlowGraph<ll> F;
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    ll n, m, c, d;
    cin >> n >> m >> c >> d;

    int s = n + m + 1, t = n + m + 2;

    F.init(s, t, n + m + 2);

    vector<string> g(n + 1);
    for (int i = 0; i < n; i++)
        cin >> g[i];

    ll blank = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (g[i][j] == '.')
            {
                blank++;
                int u = i + 1, v = j + 1 + n;
                F.add(u, v, 1);
            }
        }
    }

    // for (int i = n + 1; i <= n + m; i++)
    //     F.add(i, t, numeric_limits<ll>::max());

    ll res = d * blank, maxflow = 0;
    for (int k = 1; k <= max(n, m); k++)
    {
        for (int i = 1; i <= n; i++)
            F.add(s, i, 1);
        for (int i = n + 1; i <= n + m; i++)
            F.add(i, t, 1);
        maxflow += F.dinic();
        // cerr << k << " " << maxflow << '\n';
        res = min(res, c * k + d * (blank - maxflow));
    }

    cout << res << '\n';

    return 0;
}