Painting

#include <bits/stdc++.h>
#define int int16_t

const int kN = 71;
const int kNN = kN * kN + 1;

std::string s[kN];
std::vector<int> G[kNN];
int c[kNN][kNN];
int p[kNN];
bool used[kNN];

int32_t main() {
    int n, m;
    std::cin >> n >> m;
    int w, b, g;
    std::cin >> w >> b >> g;
    for (int i = 0; i < n; ++i)
        std::cin >> s[i];
    const int N = n * m + 2;
    int from = 0;
    int to = m * n + 1;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            int cur_num = i * m + j + 1;
            if (s[i][j] == 'W') {
                G[from].push_back(cur_num);
                c[from][cur_num] = b;
                G[cur_num].push_back(from);
            } else {
                G[to].push_back(cur_num);
                c[cur_num][to] = w;
                G[cur_num].push_back(to);
            }
            if (i + 1 < n) {
                int d_num = (i + 1) * m + j + 1;
                G[cur_num].push_back(d_num);
                c[cur_num][d_num] = g;
                G[d_num].push_back(cur_num);
                c[d_num][cur_num] = g;
            }
            if (j + 1 < m) {
                int r_num = i * m + j + 2;
                G[cur_num].push_back(r_num);
                c[cur_num][r_num] = g;
                G[r_num].push_back(cur_num);
                c[r_num][cur_num] = g;
            }
        }
    }
    int32_t ans = 0;
    std::fill(p, p + N, -1);
    while (true) {
        std::fill(used, used + N, false);
        std::fill(p, p + N, -1);
        std::queue<int> q;
        q.push(from);
        used[from] = true;
        while(!q.empty()){
            int v = q.front();
            q.pop();
            for (int nxt : G[v])
                if (!used[nxt] && c[v][nxt] > 0) {
                    p[nxt] = v;
                    used[nxt] = true;
                    q.push(nxt);
                }
        }
        if (!used[to])
            break;
        int cur = std::numeric_limits<int>::max();
        for (int i = to; p[i] != -1; i = p[i]) {
            int f = p[i];
            int st = i;
            cur = std::min(cur, c[f][st]);
        }
        ans += cur;
        for (int i = to; p[i] != -1; i = p[i]) {
            int f = p[i];
            int st = i;
            c[f][st] -= cur;
            c[st][f] += cur;
        }
    }
    std::cout << ans;
}