#include "bits/stdc++.h"
#pragma GCC optimize("O3")
#pragma GCC target("avx,avx2")
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 = 0;
    short f = 0, c = 0;
    Edge() = default;
    Edge(int to, short c) : to(to), f(0), c(c) {}
};

vector<Edge> edges;
vector<vector<int>> g;
vector<int> p;
vector<int> dist;

void add_edge(int u, int v, int w) {
    g[u].push_back(edges.size());
    edges.emplace_back(v, w);
    g[v].push_back(edges.size());
    edges.emplace_back(u, 0);
}

bool bfs() {
    memset(dist.data(), 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]) {
            int v = edges[e_i].to;
            short f = edges[e_i].f;
            short c = edges[e_i].c;
            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]];
        int v = edges[e_i].to;
        short f = edges[e_i].f;
        short c = edges[e_i].c;
        if (f < c && dist[v] == dist[u] + 1) {
            int res = dfs(v, min(flow, c - f));
            if (res) {
                edges[e_i].f += res;
                edges[e_i ^ 1].f -= res;
                return res;
            }
        }
    }
    return 0;
}

int dinic() {
    int ans = 0;
    while (bfs()) {
        memset(p.data(), 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') {
                get_vertex(i, j);
            }
            if (t[i][j] == 'W') {
                get_vertex(i, j);
            }
            if (t[i][j] == 'G') {
                get_input_vertex(i, j);
                get_output_vertex(i, j);
            }
        }
    }
    g.resize(cnt_vertexes);
    dist.resize(cnt_vertexes);
    p.resize(cnt_vertexes);
    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;
}