#include<iostream>
#include<algorithm>
#include<cstring>
#include<climits>
#include<queue>
#define int long long
using namespace std;
const int N = 509, M = N * N,INF = INT_MAX;
char mp[N][N];
int head[N],pre[N],now[N],deep[N],gap[N],sc[N],cl[N];
int cnt = 1,s,t,pointnum;
struct Edge {
	int from, to, Next, w;
}edge[M << 1];

void addedge(int u, int v, int w) {
	cnt++;
	edge[cnt].from = u;
	edge[cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].Next = head[u];
	head[u] = cnt;
}

void AddEdge(int u,int v,int w){
	addedge(u,v,w);
	addedge(v,u,0);
} 

void bfs(){//用于确定各顶点到汇点的距离
	//memset(gap, 0, sizeof(gap));//初始化间隙数组
	//memset(deep, 0, sizeof(deep));//所有点的高度初始为0
	deep[t] = 1;//汇点高度为1，其他点的高度均大于1
	queue<int>q;
	q.push(t);
	while (!q.empty()) {
		int u = q.front();
		q.pop();
		gap[deep[u]]++;//间隙数组 计算高度为deep[u]的节点个数
		for (int i = head[u]; i; i = edge[i].Next) {
			int v = edge[i].to;//v是u的邻居点
			if (edge[i ^ 1].w && (!deep[v])) {//反向边不用处理，高度不为0的点已经处理过了
				deep[v] = deep[u] + 1;
				q.push(v);
			}
		}
	}
}

int augment(){//沿着增广路径更新残留网络
	int v = t, flow = INF;
	while(v != s){//找到这条路径的流量
		int u = pre[v];//u是v向源点s方向回退的上一个点，相当于dfs的回溯
		if (edge[u].w < flow) {//路径上的最小容量就是这条路径的流量
			flow = edge[u].w;
		}
		v = edge[u].from;//更新v，继续回退
	}
	v = t;
	while (v != s) {//更新残留网络
		int u = pre[v];//向源点s方向回退
		edge[u].w -= flow;//正向边
		edge[u ^ 1].w += flow;//反向边
		v = edge[u].from;//更新v,继续回退
	}
	return flow;//返回这条路径的流量
}

int ISAP() {
	bfs();//求每个点到汇点的距离
	int flow = 0;//计算最大流
	int u = s;//从源点s开始寻找增广路径
	memcpy(now, head, sizeof(head));//当前弧优化，now是head的副本
	while (deep[s] <= pointnum) {//最大距离为n
		if (u == t) {//找到了一条增广路径
			flow += augment();//更新残留网络，更新流量
			u = s;//回到s，重新开始找一条增广路径
		}
		bool flag = false;//用于判断是否能顺利往下走
		for (int i = now[u]; i; i = edge[i].Next) {//在i的邻居中确定路径的下一个点
			int v = edge[i].to;//v是u的邻居点
			if(edge[i].w && deep[v] + 1 == deep[u]){//沿着高度递减方向找下一个点
				flag = true;//顺利找到了路径的下一个点
				pre[v] = i;//记录路径
				now[u] = i;//记录当前弧，下一次跳过它
				u = v;//u更新为路径的下一个点v
				break;//退出for循环，回到while循环，继续找路径的下一个点
			}
		}
		if (!flag) {//路径走不下去了，需要更新u的高度重新走
			gap[deep[u]]--;
			if (!gap[deep[u]]) {
				break;//u的下一个深度的点没有了，断层，退出while循环
			}
			int MinDeep = pointnum + 10;//用于计算u的邻居点的最小高度初值比n大就可以
			for (int i = head[u]; i; i = edge[i].Next) {//在u的邻居中寻找最小的高度
				int v = edge[i].to;
				if (edge[i].w && deep[v] < MinDeep) {
					MinDeep = deep[v];
				}
			}
			deep[u] = MinDeep + 1;//更新u的高度，改为v的高度加1，从而能够生成一条路径，继续往后走
			gap[deep[u]]++;//更新间隙数组，高度为deep[u]的节点个数加1
			now[u] = head[u];//记录当前弧
			if (u != s) {
				u = edge[pre[u]].from;//回退一步，相当于dfs的回溯
			}
		}
	}
	return flow;
}

void solve() {
	int c = 0, d = 0, K = 0, sum = 0,n = 0,m = 0;
	cin >> n >> m >> c >> d;
	for (int i = 1; i <= n; i++) {
		cin >> (mp[i] + 1);
		for (int j = 1; j <= m; j++) {
			if (mp[i][j] == '.') {
				mp[i][j] = 1;
			}
			else {
				mp[i][j] = 0;
			}
			sc[i] += mp[i][j];
			cl[j] += mp[i][j];
			K = max(K, cl[j]);
		}
		K = max(K, sc[i]);
		sum += sc[i];
	}
	s = n + m + 1;
	t = pointnum = s + 1;
	for (int i = 1; i <= n; i++) {
		AddEdge(s, i, 0);
	}
	for (int i = 1; i <= m; i++) {
		AddEdge(i + n, t, 0);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			if (mp[i][j]) {
				AddEdge(i, j + n, 1);
			}
		}
	}
	int ans = LLONG_MAX,tmp = 0;
	for (int k = 0; k <= K; k++) {
		if (k) {
			memset(gap + 1, 0, sizeof(*gap) * pointnum);
			memset(deep + 1, 0, sizeof(*deep) * pointnum);
			for (int i = 1; i <= n; i++) {
				edge[i * 2].w++;
			}
			for (int i = 1; i <= m; i++) {
				edge[(i + n) * 2].w++;
			}
		}
		tmp += ISAP();
		ans = min(ans, c * k + d * (sum - tmp));
	}
	cout << ans << endl;
}

signed main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	solve();
	return 0;
}