#include <bits/stdc++.h>
using namespace std;
std::mt19937 rnd(
    (int)std::chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXH = 100000;
const int MAXW = 100000;
const int MAXDIM = MAXH >= MAXW ? MAXH : MAXW;
const int MAXQ = 100000;
const int MAXS = 4 * MAXDIM;
int h, w, nq;
char initlft[MAXH + 1];
char initrgt[MAXH + 1];
char inittop[MAXW + 1];
char initbot[MAXW + 1];
char qside[MAXQ];
int ql[MAXQ], qr[MAXQ], qans[MAXQ + 1];
struct SegNode {
  int cost[2][2][2][2];
  bool lazyfliptop, lazyflipbot;
  int cntblue[2], cntred[2];
};
struct SegTree {
  int n;
  int crosscost, lftcost[2], rgtcost[2];
  char inittop[MAXDIM + 1];
  char initbot[MAXDIM + 1];
  SegNode sval[MAXS];
  void sfliptop(int x) {
    swap(sval[x].cntblue[0], sval[x].cntred[0]);
    for (int lftcol = (0); lftcol < (2); ++lftcol)
      for (int rgtcol = (0); rgtcol < (2); ++rgtcol)
        for (int botflip = (0); botflip < (2); ++botflip)
          swap(sval[x].cost[lftcol][rgtcol][0][botflip],
               sval[x].cost[lftcol][rgtcol][1][botflip]);
    sval[x].lazyfliptop = !sval[x].lazyfliptop;
  }
  void sflipbot(int x) {
    swap(sval[x].cntblue[1], sval[x].cntred[1]);
    for (int lftcol = (0); lftcol < (2); ++lftcol)
      for (int rgtcol = (0); rgtcol < (2); ++rgtcol)
        for (int topflip = (0); topflip < (2); ++topflip)
          swap(sval[x].cost[lftcol][rgtcol][topflip][0],
               sval[x].cost[lftcol][rgtcol][topflip][1]);
    sval[x].lazyflipbot = !sval[x].lazyflipbot;
  }
  void spush(int x) {
    if (sval[x].lazyfliptop)
      sfliptop(2 * x + 1), sfliptop(2 * x + 2), sval[x].lazyfliptop = false;
    if (sval[x].lazyflipbot)
      sflipbot(2 * x + 1), sflipbot(2 * x + 2), sval[x].lazyflipbot = false;
  }
  void spull(int x) {
    const SegNode &a = sval[2 * x + 1];
    const SegNode &b = sval[2 * x + 2];
    for (int side = (0); side < (2); ++side)
      sval[x].cntblue[side] = a.cntblue[side] + b.cntblue[side];
    for (int side = (0); side < (2); ++side)
      sval[x].cntred[side] = a.cntred[side] + b.cntred[side];
    for (int lftcol = (0); lftcol < (2); ++lftcol)
      for (int rgtcol = (0); rgtcol < (2); ++rgtcol)
        for (int topflip = (0); topflip < (2); ++topflip)
          for (int botflip = (0); botflip < (2); ++botflip) {
            int cur = INT_MAX;
            for (int midcol1 = (0); midcol1 < (2); ++midcol1)
              for (int midcol2 = (0); midcol2 < (2); ++midcol2) {
                int acost = a.cost[lftcol][midcol1][topflip][botflip];
                int bcost = b.cost[midcol2][rgtcol][topflip][botflip];
                int ccost = midcol1 == midcol2 ? 0 : crosscost;
                if (acost == INT_MAX || bcost == INT_MAX) continue;
                cur = min(cur, acost + bcost + ccost);
              }
            sval[x].cost[lftcol][rgtcol][topflip][botflip] = cur;
          }
  }
  void sinit(int x, int l, int r) {
    sval[x].lazyfliptop = sval[x].lazyflipbot = false;
    if (l == r) {
      int sa = inittop[l] == 'B' ? 0 : 1;
      int sb = initbot[l] == 'B' ? 0 : 1;
      sval[x].cntblue[0] = sa == 0 ? 1 : 0,
      sval[x].cntred[0] = 1 - sval[x].cntblue[0];
      sval[x].cntblue[1] = sb == 0 ? 1 : 0,
      sval[x].cntred[1] = 1 - sval[x].cntblue[1];
      for (int lftcol = (0); lftcol < (2); ++lftcol)
        for (int rgtcol = (0); rgtcol < (2); ++rgtcol)
          for (int topflip = (0); topflip < (2); ++topflip)
            for (int botflip = (0); botflip < (2); ++botflip) {
              int cur;
              if (lftcol == rgtcol) {
                int a = sa;
                if (topflip) a = 1 - a;
                int b = sb;
                if (botflip) b = 1 - b;
                cur = (a == lftcol ? 0 : 1) + (b == lftcol ? 0 : 1);
              } else {
                cur = INT_MAX;
              }
              sval[x].cost[lftcol][rgtcol][topflip][botflip] = cur;
            }
    } else {
      int m = l + (r - l) / 2;
      sinit(2 * x + 1, l, m);
      sinit(2 * x + 2, m + 1, r);
      spull(x);
    }
  }
  void sflip(int x, int l, int r, int L, int R, bool istop) {
    if (L <= l && r <= R) {
      if (istop)
        sfliptop(x);
      else
        sflipbot(x);
    } else {
      int m = l + (r - l) / 2;
      spush(x);
      if (L <= m) sflip(2 * x + 1, l, m, L, R, istop);
      if (m + 1 <= R) sflip(2 * x + 2, m + 1, r, L, R, istop);
      spull(x);
    }
  }
  void init() { sinit(0, 0, n - 1); }
  void flip(int l, int r, bool istop) { sflip(0, 0, n - 1, l, r, istop); }
  int calc() {
    int ret = INT_MAX;
    for (int lftcol = (0); lftcol < (2); ++lftcol)
      for (int rgtcol = (0); rgtcol < (2); ++rgtcol) {
        int cur = sval[0].cost[lftcol][rgtcol][0][0];
        if (cur == INT_MAX) continue;
        cur += lftcost[lftcol];
        cur += rgtcost[rgtcol];
        ret = min(ret, cur);
      }
    return ret;
  }
};
SegTree stopbot, slftrgt;
int calc() {
  stopbot.lftcost[0] = slftrgt.sval[0].cntred[0],
  stopbot.lftcost[1] = slftrgt.sval[0].cntblue[0];
  stopbot.rgtcost[0] = slftrgt.sval[0].cntred[1],
  stopbot.rgtcost[1] = slftrgt.sval[0].cntblue[1];
  slftrgt.lftcost[0] = stopbot.sval[0].cntred[0],
  slftrgt.lftcost[1] = stopbot.sval[0].cntblue[0];
  slftrgt.rgtcost[0] = stopbot.sval[0].cntred[1],
  slftrgt.rgtcost[1] = stopbot.sval[0].cntblue[1];
  return min(stopbot.calc(), slftrgt.calc());
}
void solve() {
  stopbot.n = w, stopbot.crosscost = h;
  for (int i = (0); i <= (w); ++i)
    stopbot.inittop[i] = inittop[i], stopbot.initbot[i] = initbot[i];
  stopbot.init();
  slftrgt.n = h, slftrgt.crosscost = w;
  for (int i = (0); i <= (h); ++i)
    slftrgt.inittop[i] = initlft[i], slftrgt.initbot[i] = initrgt[i];
  slftrgt.init();
  qans[0] = calc();
  for (int i = (0); i < (nq); ++i) {
    char side = qside[i];
    int l = ql[i], r = qr[i];
    if (side == 'U') stopbot.flip(l, r, true);
    if (side == 'D') stopbot.flip(l, r, false);
    if (side == 'L') slftrgt.flip(l, r, true);
    if (side == 'R') slftrgt.flip(l, r, false);
    qans[i + 1] = calc();
  }
}
void run() {
  scanf("%d%d%d", &h, &w, &nq);
  scanf("%s", initlft);
  scanf("%s", initrgt);
  scanf("%s", inittop);
  scanf("%s", initbot);
  for (int i = (0); i < (nq); ++i)
    scanf(" %c%d%d", &qside[i], &ql[i], &qr[i]), --ql[i], --qr[i];
  solve();
  for (int i = (0); i <= (nq); ++i) printf("%d\n", qans[i]);
}
void stress() {
  h = MAXH, w = MAXW, nq = MAXQ;
  for (int i = (0); i < (h); ++i) initlft[i] = "BR"[rnd() % 2];
  initlft[h] = '\0';
  for (int i = (0); i < (h); ++i) initrgt[i] = "BR"[rnd() % 2];
  initrgt[h] = '\0';
  for (int i = (0); i < (w); ++i) inittop[i] = "BR"[rnd() % 2];
  inittop[w] = '\0';
  for (int i = (0); i < (w); ++i) initbot[i] = "BR"[rnd() % 2];
  initbot[w] = '\0';
  for (int i = (0); i < (nq); ++i) {
    qside[i] = "UDLR"[rnd() % 4];
    int dim = qside[i] == 'U' || qside[i] == 'D' ? w : h;
    ql[i] = rnd() % dim, qr[i] = rnd() % dim;
    if (ql[i] > qr[i]) swap(ql[i], qr[i]);
  }
  solve();
  printf("done\n");
}
int main() {
  run();
  return 0;
}
