#include <bits/stdc++.h>
using namespace std;
inline int read() {
  char ch = getchar();
  int nega = 1;
  while (!isdigit(ch)) {
    if (ch == '-') nega = -1;
    ch = getchar();
  }
  int ans = 0;
  while (isdigit(ch)) {
    ans = ans * 10 + ch - 48;
    ch = getchar();
  }
  if (nega == -1) return -ans;
  return ans;
}
inline char rdchar() {
  char ch = getchar();
  while (!(ch >= 'a' && ch <= 'z') && !(ch >= 'A' && ch <= 'Z') &&
         !(ch >= '0' && ch <= '9'))
    ch = getchar();
  return ch;
}
void print(vector<int> x) {
  for (int i = 0; i < (int)x.size(); i++)
    printf("%d%c", x[i], " \n"[i == (int)x.size() - 1]);
}
template <typename _Tp, typename... Args>
_Tp min(const _Tp &a, const _Tp &b, const Args &...args) {
  return a < b ? min(a, args...) : min(b, args...);
}
template <typename _Tp, typename... Args>
_Tp max(const _Tp &a, const _Tp &b, const Args &...args) {
  return a < b ? max(b, args...) : max(a, args...);
}
struct Mat {
  int a[2][2];
  Mat() { memset(a, 0, sizeof(a)); }
  Mat operator*(const Mat &x) const {
    Mat ans;
    memset(ans.a, 0x3f, sizeof(ans.a));
    for (int i = 0; i < 2; i++)
      for (int j = 0; j < 2; j++)
        for (int k = 0; k < 2; k++)
          ans.a[i][j] = min(ans.a[i][j], a[i][k] + x.a[k][j]);
    return ans;
  }
};
int l[100005], r[100005], u[100005], d[100005];
int l1, r1, u1, d1;
int n, m, Q;
Mat getMat(int t) {
  Mat ans;
  ans.a[0][0] = t, ans.a[0][1] = n + 2 - t;
  ans.a[1][0] = n + t, ans.a[1][1] = 2 - t;
  return ans;
}
struct SMT2 {
  int *a;
  int t[100005 * 4], tag[100005 * 4];
  void build(int u, int l, int r) {
    tag[u] = 0;
    if (l == r) {
      t[u] = a[l];
      return;
    }
    build((u << 1), l, ((l + r) / 2)),
        build((u << 1 | 1), ((l + r) / 2) + 1, r);
    t[u] = t[(u << 1)] + t[(u << 1 | 1)];
  }
  void flip(int u, int l, int r) {
    tag[u] ^= 1;
    t[u] = r - l + 1 - t[u];
  }
  void pushdown(int u, int l, int r) {
    if (tag[u])
      flip((u << 1), l, ((l + r) / 2)),
          flip((u << 1 | 1), ((l + r) / 2) + 1, r), tag[u] = 0;
  }
  void update(int u, int l, int r, int L, int R) {
    if (L <= l && r <= R) {
      flip(u, l, r);
      return;
    }
    pushdown(u, l, r);
    if (((l + r) / 2) >= L) update((u << 1), l, ((l + r) / 2), L, R);
    if (((l + r) / 2) < R) update((u << 1 | 1), ((l + r) / 2) + 1, r, L, R);
    t[u] = t[(u << 1)] + t[(u << 1 | 1)];
  }
  pair<int, int> query() { return make_pair(t[1], n - t[1]); }
} L, R;
struct SMT1 {
  Mat t[100005 * 4][4];
  int tag1[100005 * 4], tag2[100005 * 4];
  void pushup(int u) {
    for (int i = 0; i < 4; i++) t[u][i] = t[(u << 1)][i] * t[(u << 1 | 1)][i];
  }
  void flip1(int u) {
    tag1[u] ^= 1;
    swap(t[u][0], t[u][1]), swap(t[u][2], t[u][3]);
  }
  void flip2(int u) {
    tag2[u] ^= 1;
    swap(t[u][0], t[u][2]), swap(t[u][1], t[u][3]);
  }
  void pushdown(int u) {
    if (tag1[u]) flip1((u << 1)), flip1((u << 1 | 1)), tag1[u] = 0;
    if (tag2[u]) flip2((u << 1)), flip2((u << 1 | 1)), tag2[u] = 0;
  }
  void build(int u, int l, int r) {
    tag1[u] = tag2[u] = 0;
    if (l == r) {
      t[u][0] = getMat(::u[l] + d[l]);
      t[u][1] = getMat(::u[l] + !d[l]);
      t[u][2] = getMat(!::u[l] + d[l]);
      t[u][3] = getMat(!::u[l] + !d[l]);
      return;
    }
    build((u << 1), l, ((l + r) / 2)),
        build((u << 1 | 1), ((l + r) / 2) + 1, r);
    pushup(u);
  }
  void update1(int u, int l, int r, int L, int R) {
    if (L <= l && r <= R) {
      flip1(u);
      return;
    }
    pushdown(u);
    if (((l + r) / 2) >= L) update1((u << 1), l, ((l + r) / 2), L, R);
    if (((l + r) / 2) < R) update1((u << 1 | 1), ((l + r) / 2) + 1, r, L, R);
    pushup(u);
  }
  void update2(int u, int l, int r, int L, int R) {
    if (L <= l && r <= R) {
      flip2(u);
      return;
    }
    pushdown(u);
    if (((l + r) / 2) >= L) update2((u << 1), l, ((l + r) / 2), L, R);
    if (((l + r) / 2) < R) update2((u << 1 | 1), ((l + r) / 2) + 1, r, L, R);
    pushup(u);
  }
  int query() {
    Mat f;
    pair<int, int> x = L.query();
    f.a[0][0] = x.first, f.a[0][1] = x.second;
    f = f * t[1][0];
    int g[] = {f.a[0][0], f.a[0][1]};
    x = R.query();
    return min(g[0] + x.first, g[1] + x.second);
  }
} smt;
struct Query {
  char opt;
  int l, r;
} q[100005];
int ans[100005];
signed main() {
  cin >> n >> m >> Q;
  for (int i = 1; i <= n; i++) l[i] = rdchar() == 'B';
  for (int i = 1; i <= n; i++) r[i] = rdchar() == 'B';
  for (int i = 1; i <= m; i++) u[i] = rdchar() == 'B';
  for (int i = 1; i <= m; i++) d[i] = rdchar() == 'B';
  for (int i = 1; i <= Q; i++)
    q[i].opt = rdchar(), q[i].l = read(), q[i].r = read(), ans[i] = 0x3f3f3f3f;
  L.a = l, R.a = r;
  L.build(1, 1, n), R.build(1, 1, n);
  smt.build(1, 1, m);
  ans[0] = smt.query();
  for (int i = 1; i <= Q; i++) {
    if (q[i].opt == 'L') L.update(1, 1, n, q[i].l, q[i].r);
    if (q[i].opt == 'R') R.update(1, 1, n, q[i].l, q[i].r);
    if (q[i].opt == 'D') smt.update1(1, 1, m, q[i].l, q[i].r);
    if (q[i].opt == 'U') smt.update2(1, 1, m, q[i].l, q[i].r);
    ans[i] = min(ans[i], smt.query());
  }
  swap(n, m), swap(l, u), swap(r, d);
  L.a = l, R.a = r;
  L.build(1, 1, n), R.build(1, 1, n);
  smt.build(1, 1, m);
  ans[0] = min(ans[0], smt.query());
  for (int i = 1; i <= Q; i++) {
    if (q[i].opt == 'L')
      q[i].opt = 'U';
    else if (q[i].opt == 'R')
      q[i].opt = 'D';
    else if (q[i].opt == 'U')
      q[i].opt = 'L';
    else if (q[i].opt == 'D')
      q[i].opt = 'R';
  }
  L.a = l, R.a = r;
  L.build(1, 1, n), R.build(1, 1, n);
  smt.build(1, 1, m);
  ans[0] = min(ans[0], smt.query());
  for (int i = 1; i <= Q; i++) {
    if (q[i].opt == 'L') L.update(1, 1, n, q[i].l, q[i].r);
    if (q[i].opt == 'R') R.update(1, 1, n, q[i].l, q[i].r);
    if (q[i].opt == 'D') smt.update1(1, 1, m, q[i].l, q[i].r);
    if (q[i].opt == 'U') smt.update2(1, 1, m, q[i].l, q[i].r);
    ans[i] = min(ans[i], smt.query());
  }
  for (int i = 0; i <= Q; i++) printf("%d\n", ans[i]);
  return 0;
}
