#include <bits/stdc++.h>
struct count_seg {
  struct node {
    std::array<int, 2> c;
    bool flip = false;
  };
  std::vector<node> seg;
  count_seg() : seg() {}
  explicit count_seg(int N) : seg(2 * N) {}
  std::array<int, 2> query_all() { return seg[1].c; }
  void update_node(int a) {
    int N = int(seg.size()) >> 1;
    if (a >= N) {
      seg[a].c[0] = 0, seg[a].c[1] = 1;
    } else {
      seg[a].c[0] = seg[2 * a].c[0] + seg[2 * a + 1].c[0];
      seg[a].c[1] = seg[2 * a].c[1] + seg[2 * a + 1].c[1];
    }
    if (seg[a].flip) std::swap(seg[a].c[0], seg[a].c[1]);
  }
  void flip_node(int a) {
    seg[a].flip ^= 1;
    std::swap(seg[a].c[0], seg[a].c[1]);
  }
  void flip_leaf_lazy(int l) {
    int N = int(seg.size()) >> 1;
    seg[N + l].flip ^= 1;
  }
  void flip_range(int l, int r) {
    int N = int(seg.size()) >> 1;
    for (int a = l + N, b = r + N; a < b; a >>= 1, b >>= 1) {
      if (a & 1) flip_node(a++);
      if (b & 1) flip_node(--b);
    }
    for (int a = l + N; a; a >>= 1) update_node(a);
    for (int b = r + N - 1; b; b >>= 1) update_node(b);
  }
  void update_all() {
    for (int i = int(seg.size()) - 1; i; --i) update_node(i);
  }
};
struct big_seg {
  struct mat {
    std::array<std::array<std::array<int, 2>, 2>, 2> v;
    friend mat operator*(const mat& a, const mat& b) {
      mat res;
      for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
          for (int z = 0; z < 2; z++) {
            res.v[i][j][z] = std::min(a.v[i][j][0] + b.v[i][j][z],
                                      a.v[i][j][1] + b.v[!i][!j][!z]);
          }
        }
      }
      return res;
    }
    int eval(std::array<int, 2> st, std::array<int, 2> en) const {
      int res = st[0] + v[0][0][0] + en[0];
      for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
          res = std::min(res, st[i] + v[i][i][i ^ j] + en[j]);
        }
      }
      return res;
    }
  };
  struct node {
    mat m;
    std::array<bool, 2> flip = {false, false};
  };
  int N, M;
  std::vector<node> seg;
  big_seg() : N(0), seg() {}
  big_seg(int N_, int M_) : N(N_), M(M_), seg() {
    int S = 1;
    while (S < N) S *= 2;
    seg.resize(2 * S);
  }
  mat query_all() { return seg[1].m; }
  void update_node(int a) {
    int S = int(seg.size()) >> 1;
    if (a >= S) {
      if (a - S < N) {
        for (int i = 0; i < 2; i++) {
          for (int j = 0; j < 2; j++) {
            seg[a].m.v[i][j][0] = i + j;
            seg[a].m.v[i][j][1] = i + j + M;
          }
        }
      } else {
        for (int i = 0; i < 2; i++) {
          for (int j = 0; j < 2; j++) {
            seg[a].m.v[i][j][0] = 0;
            seg[a].m.v[i][j][1] = 0 + M;
          }
        }
      }
    } else {
      seg[a].m = seg[2 * a].m * seg[2 * a + 1].m;
    }
    if (seg[a].flip[0]) {
      swap(seg[a].m.v[0], seg[a].m.v[1]);
    }
    if (seg[a].flip[1]) {
      swap(seg[a].m.v[0][0], seg[a].m.v[0][1]);
      swap(seg[a].m.v[1][0], seg[a].m.v[1][1]);
    }
  }
  void flip_node(int a, bool z) {
    seg[a].flip[z] ^= 1;
    if (z == 0) {
      swap(seg[a].m.v[0], seg[a].m.v[1]);
    } else if (z == 1) {
      swap(seg[a].m.v[0][0], seg[a].m.v[0][1]);
      swap(seg[a].m.v[1][0], seg[a].m.v[1][1]);
    } else
      assert(false);
  }
  void flip_leaf_lazy(int l, bool z) {
    int S = int(seg.size()) >> 1;
    seg[S + l].flip[z] ^= 1;
  }
  void flip_range(int l, int r, bool z) {
    int S = int(seg.size()) >> 1;
    for (int a = l + S, b = r + S; a < b; a >>= 1, b >>= 1) {
      if (a & 1) flip_node(a++, z);
      if (b & 1) flip_node(--b, z);
    }
    for (int a = l + S; a; a >>= 1) update_node(a);
    for (int b = r + S - 1; b; b >>= 1) update_node(b);
  }
  void update_all() {
    for (int i = int(seg.size()) - 1; i; --i) update_node(i);
  }
};
int main() {
  using namespace std;
  ios_base::sync_with_stdio(false), cin.tie(nullptr);
  array<int, 2> N;
  int Q;
  cin >> N[0] >> N[1] >> Q;
  array<array<count_seg, 2>, 2> count_segs;
  array<big_seg, 2> big_segs;
  for (int a = 0; a < 2; a++) {
    big_segs[a] = big_seg(N[a], N[!a]);
    for (int b = 0; b < 2; b++) {
      count_segs[a][b] = count_seg(N[a]);
      string S;
      cin >> S;
      assert(int(S.size()) == N[a]);
      for (int i = 0; i < N[a]; i++) {
        if (S[i] == 'R') {
          count_segs[a][b].flip_leaf_lazy(i);
          big_segs[a].flip_leaf_lazy(i, b);
        }
      }
      count_segs[a][b].update_all();
    }
    big_segs[a].update_all();
  }
  auto query = [&]() -> int {
    int ans = 2 * N[0] + 2 * N[1];
    for (int z = 0; z < 2; z++) {
      int cnd = big_segs[!z].query_all().eval(count_segs[z][0].query_all(),
                                              count_segs[z][1].query_all());
      ans = min(ans, cnd);
    }
    return ans;
  };
  cout << query() << '\n';
  for (int q = 0; q < Q; q++) {
    char side;
    int l, r;
    cin >> side >> l >> r;
    l--;
    bool dim, z;
    switch (side) {
      case 'L':
        dim = 0, z = 0;
        break;
      case 'R':
        dim = 0, z = 1;
        break;
      case 'U':
        dim = 1, z = 0;
        break;
      case 'D':
        dim = 1, z = 1;
        break;
      default:
        assert(false);
    }
    assert(0 <= l && l < r && r <= N[dim]);
    count_segs[dim][z].flip_range(l, r);
    big_segs[dim].flip_range(l, r, z);
    cout << query() << '\n';
  }
  return 0;
}
