#include "bits/stdc++.h"
using namespace std;

char t[3000][3000];

int S = 0;
int T = 1;
int cnt_vertexes = 2;

map<pair<int, int>, int> saved_input_vertexes;
int get_input_vertex(int i, int j) {
    if (!saved_input_vertexes.contains(make_pair(i, j))) {
        saved_input_vertexes[make_pair(i, j)] = cnt_vertexes++;
    }
    return saved_input_vertexes[make_pair(i, j)];
}

map<pair<int, int>, int> saved_output_vertexes;
int get_output_vertex(int i, int j) {
    if (!saved_output_vertexes.contains(make_pair(i, j))) {
        saved_output_vertexes[make_pair(i, j)] = cnt_vertexes++;
    }
    return saved_output_vertexes[make_pair(i, j)];
}

map<pair<int, int>, int> saved_vertexes;
int get_vertex(int i, int j) {
    if (!saved_vertexes.contains(make_pair(i, j))) {
        saved_vertexes[make_pair(i, j)] = cnt_vertexes++;
    }
    return saved_vertexes[make_pair(i, j)];
}

struct Edge {
    int to, f, c;
};

Edge edges[3'000'000];
int cnt_edges = 0;

vector<int> g[10'000'000];

void add_edge(int u, int v, int w) {
    edges[cnt_edges] = Edge{v, 0, w};
    g[u].push_back(cnt_edges);
    cnt_edges++;
    edges[cnt_edges] = Edge{u, 0, 0};
    g[v].push_back(cnt_edges);
    cnt_edges++;
}

int dist[10'000'000];
int p[10'000'000];

bool bfs() {
    memset(dist, 1, sizeof(int) * cnt_vertexes);
    int inf = dist[S];
    dist[S] = 0;
    deque<int> Q = {S};
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop_front();
        for (int e_i : g[u]) {
            auto& [v, f, c] = edges[e_i];
            if (f < c && dist[v] > dist[u] + 1) {
                dist[v] = dist[u] + 1;
                Q.push_back(v);
            }
        }
    }
    return dist[T] != inf;
}

int dfs(int u, int flow = INT32_MAX) {
    if (u == T) {
        return flow;
    }
    for (; p[u] < g[u].size(); p[u]++) {
        int e_i = g[u][p[u]];
        auto& [v, f, c] = edges[e_i];
        if (f < c && dist[v] == dist[u] + 1) {
            int res = dfs(v, min(flow, c - f));
            if (res) {
                f += res;
                return res;
            }
        }
    }
    return 0;
}

int dinic() {
    int ans = 0;
    while (bfs()) {
        memset(p, 0, sizeof(int) * cnt_vertexes);
        while (int res = dfs(S)) {
            ans += res;
        }
    }
    return ans;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> t[i][j];
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (t[i][j] == 'R') {
                add_edge(S, get_vertex(i, j), 1);
            }
            if (t[i][j] == 'W') {
                add_edge(get_vertex(i, j), T, 1);
            }
            if (t[i][j] == 'G') {
                add_edge(get_input_vertex(i, j), get_output_vertex(i, j), 1);
            }
            if (i + 2 < n && t[i][j] == 'R' && t[i + 1][j] == 'G' && t[i + 2][j] == 'W') {
                add_edge(get_vertex(i, j), get_input_vertex(i + 1, j), 1);
                add_edge(get_output_vertex(i + 1, j), get_vertex(i + 2, j), 1);
            }
            if (j + 2 < m && t[i][j] == 'R' && t[i][j + 1] == 'G' && t[i][j + 2] == 'W') {
                add_edge(get_vertex(i, j), get_input_vertex(i, j + 1), 1);
                add_edge(get_output_vertex(i, j + 1), get_vertex(i, j + 2), 1);
            }
        }
    }

    cout << dinic() << '\n';
    return 0;
}