#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;

//#define DBG_S   // struktury
//#define DBG     // obliczenia
//#define DBG_0   // tylko co 10k numer chłopca

/*
  potrzebne operacje dla tego zadania:
    GetMinW(IDX from, IDX to, VAL &mins, VAL &sum);  // minimalna suma narastająco od lewej oraz suma zakresu
    FindMinW(IDX from, IDX to, VAL v); // znalezienie najmniejszej pozycji na której suma narastająco od lewej <= v

*/

template <class IDX, class VAL>
class DP {
  public:
    struct Node {
      VAL sum;
      VAL mins; // minimalna suma  narastająco od lewej w tym przedziale
    };
    IDX imin, imax;
    IDX size;    // number of indeeces
    IDX n;       // node number (size rounded up to 2^k)
    VAL *vals;   // wygrane w liściach
    VAL *tmins;   // minimalne wygrane w liściach
    Node *nodes; // nodes
    void Construct();

    inline DP() {}; //empty (just for declaration)
    DP(IDX _imin, IDX _imax, VAL *_vals, VAL *_mins);


    void _GetMinW(IDX inode, IDX left, IDX right, IDX from, IDX to, VAL &mins, VAL &sum);
    void GetMinW(IDX from, IDX to, VAL &mins, VAL &sum);

    IDX _FindMinW(IDX inode, IDX left, IDX right, IDX from, IDX to, VAL v, VAL &sum);
    IDX FindMinW(IDX from, IDX to, VAL v, VAL &sum);

};

////////////////////////////////////////////////////////////////////////

template <class IDX, class VAL>
void DP<IDX, VAL>::Construct()
{
  n = 2; // minimal leaves number (at least 2 leaves and 1 node)
  while(n < size) n *= 2;
  nodes = new Node[n];

  // initialize lowest level nodes ----------------------------
  IDX node;
  IDX node0 = n / 2; // leftmost lowest node
  IDX left = 0;      // beginning of the interval

  for(node = node0; left < size; ++node, left += 2) {
    if(left + 1 >= size) {
      nodes[node].sum = vals[left];
      nodes[node].mins = tmins[left];
    }
    else {
      nodes[node].sum = vals[left] + vals[left + 1];
      nodes[node].mins = min(tmins[left], vals[left] + tmins[left + 1]);
    }
  }

  // initialize higher nodes ----------------------------------
  node0 /= 2; // leftmost node on the second level from the bottom
  IDX ihsize = 2; // half of interval size
  while(node0 > 0) {
    for(node = node0, left = 0; left < size; ++node, left += ihsize * 2) {
      IDX node2 = 2 * node; // left child node
      if(left + ihsize >= size) {
        nodes[node].sum = nodes[node2].sum;
        nodes[node].mins = nodes[node2].mins;
        //TODO:
      }
      else {
        nodes[node].sum = nodes[node2].sum + nodes[node2 + 1].sum;
        nodes[node].mins = min(nodes[node2].mins, nodes[node2].sum + nodes[node2 + 1].mins);
      }
    }
    node0 /= 2;
    ihsize *= 2;
  }
}

////////////////////////////////////////////////////////////////////////

template <class IDX, class VAL>
DP<IDX, VAL>::DP(IDX _imin, IDX _imax, VAL *_vals, VAL *_mins)
{
  imin = _imin;
  imax = _imax;
  size = _imax - _imin + 1;
  vals = new VAL[size];
  tmins = new VAL[size];
  for (int i = 0; i < size; ++i) {
    vals[i] = _vals[i];
    tmins[i] = _mins[i];
  }

  Construct();
}

////////////////////////////////////////////////////////////////////////


template <class IDX, class VAL>
void DP<IDX, VAL>::_GetMinW(IDX inode, IDX left, IDX right, IDX from, IDX to, VAL &mins, VAL &sum)
{
  if(inode >= n) {  // leafe
    sum = vals[left];
    mins = tmins[left];
  }
  else if(from <= left && to >= right) { // the whole interval
    sum = nodes[inode].sum;
    mins = nodes[inode].mins;
  }
  else {
    bool went_left = false;
    VAL mins2, sum2;  // z prawego
    IDX m = (left + right) / 2; // end of the left subinterval
    if(from <= m) {
      went_left = true;
      _GetMinW(inode * 2, left, m, from, to, mins, sum); // left subinterval
    }
    if(min(to, size - 1) > m) {
      _GetMinW(inode * 2 + 1, m + 1, right, from, to, mins2, sum2); // right subinterval
      if (went_left) {
        mins = min(mins, sum + mins2);
        sum += sum2;
      }
      else {
        mins = mins2;
        sum = sum2;
      }
    }
  }
  #ifdef DBG
  //printf("  _GetMinW(%d, %d..%d, %d..%d, mins=%I64d sum=%I64d)\n", inode, left, right, from, to, mins, sum);
  #endif // DBG

}

template <class IDX, class VAL>
void DP<IDX, VAL>::GetMinW(IDX from, IDX to, VAL &mins, VAL &sum)
{
  _GetMinW(1, 0, n - 1, from - imin, to == imax ? n - 1 : to - imin, mins, sum);
}

////////////////////////////////////////////////////////////////////////
template <class IDX, class VAL>
IDX DP<IDX, VAL>::_FindMinW(IDX inode, IDX left, IDX right, IDX from, IDX to, VAL v, VAL &sum)
{
  bool went_left = false;
  IDX res;
  VAL sum2;

  #ifdef DBG
  //printf("  _FindMinW(%d, %d..%d, %d..%d, %I64d)\n", inode, left, right, from, to, v);
  #endif // DBG

  if(inode >= n) {  // leafe
    sum = vals[left];
    if (tmins[left] <= v)
      return left;
    else
      return -1;
  }
  else if(from <= left && to >= right) {    // the whole interval
    sum = nodes[inode].sum;
    if (nodes[inode].mins > v)
      return -1; // tutaj nie ma
  }
  // jeśli pytanie o cały przedział to tu dochodzimy tylko jak wiadomo,że wynik jest w tym przedziale

  IDX m = (left + right) / 2; // end of the left subinterval
  if (from <= m) { // szukamy po lewej
    went_left = true;
    res = _FindMinW(inode * 2, left, m, from, to, v, sum);
    if (res != -1)
      return res;  // znaleziono po lewej
  }

  if(min(to, size - 1) > m) { // szukamy po prawej (jak nie znaleziono po lewej)
    res = _FindMinW(inode * 2 + 1, m + 1, right, from, to, went_left ? v - sum : v, sum2); // right subinterval
    sum = went_left ? sum + sum2 : sum2;
  }
  return res;
}

template <class IDX, class VAL>
IDX DP<IDX, VAL>::FindMinW(IDX from, IDX to, VAL v, VAL &sum)
{
  return _FindMinW(1, 0, n - 1, from - imin, to == imax ? n - 1 : to - imin, v, sum);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef DEBUG
void print(DP<int, long long> &d) {
  int node = 1;
  printf("  n=%d size=%d\n", d.n, d.size);
  while(node < d.n) {
    int node2 = node * 2; // leftmost node on the next level
    for(; node < node2; ++node) {
      printf("    %d: %I64d %I64d\n", node, d.nodes[node].sum, d.nodes[node].mins);
    }
    printf("\n");
    node = node2;
  }
  printf("    ");
  for(int i = 0; i < d.size; ++i) printf("%I64d ", d.vals[i]);
  printf("\n    ");
  for(int i = 0; i < d.size; ++i) printf("%I64d ", d.tmins[i]);
  printf("\n\n");
}
#endif // DEBUG

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


int n, m;
int *b;  // oszczędności
char *a; // cykl automatu

struct CyklMaszyny {
  int i;            // nowe położenie chłopca w kolejce
  long long wygr;   // sumaryczna wygrana chłopca w cyklu maszyny
  long long minw;   // minimalna wygrana narastająco w cyklu maszyny
  bool ok;          // czy już był wzięty do jakiegoś dużego cyklu
};

struct DuzyCykl {
  vector<int> ti;       // pozycje początkowe chłopców w kolejce
  //long long wygr;       // sumaryczna wygrana w całym cyklu - niepotrzebne bo i tak wyciągane  z drzewa
  DP<int, long long> d; // drzewo przedziałowe z wygranymi w cyklach maszyny
};

struct Start {
  int nrc;   // numer dużego cyklu
  int i;     // pozycja chłopca w dużym cyklu
};

void czytaj()
{
  int i;
  scanf("%d", &n);
  b = new int[n];
  for (i = 0; i < n; ++i) scanf("%d", b + i);
  scanf("%d", &m);
  a = new char[m + 10];
  scanf("%s", a);
  #ifdef DBG
  printf("przeczytane n=%d, m=%d\n", n, m);
  #endif // DBG
}

long long licz()
{
  /*
    Dla każdej pozycji chłopca 0..n-1 wyznaczyć zmianę w cyklu maszyny: nowe położenie, sumę wygranych, min wygraną narastająco (max przegraną).
    Wyznaczyć cykle w powyższych danych:
      kolejne pozycje w cyklu,
      sumę wygranych w całym cyklu,
      min wygraną narastająco (drzewo przedziałowe bo chcemy to znać osobno dla każdej pozycji startowej).
    Dla każdego chłopca k sprawdzić czy i kiedy przegra:
      liczba gier := 0
      Przegra jeśli: min wygrana narastająco w jego dużym cyklu <= -b[k] LUB suma wygranych w dużym cyklu < 0.
        UWAGA: tutaj potrzebna jest min wygrana narastająco w dużym cyklu od pozycji chłopca (drzewo przedziałowe)
      Wyznaczyć najmniejszą liczbę dużych cykli q, że min wygrana narastająco w dużym cyklu <= -(b[k] + q * suma wygranych w dużym cyklu):
        Doliczyć q * m * długość cyklu do liczby gier chłopca.
        Zaktualizować b[k]
      Dalej wyznaczyć największą pozycję q w dużym cyklu dla której min wygrana narastająco w małym cyklu > - (b[k] + suma narastająco wygranych z poprzednich małych cykli).
        Doliczyć q * m do liczby gier chłopca.
        Zaktualizować b[k]
      Symulować kolejne gry chłopca dopóki b[k] > = 0
        Doliczyć do liczby gier: 1 + pozycja początkowa w danym cyklu maszyny dla pierwszej gry w cyklu LUB n jeśli to kolejna gra.
        Zaktualizować b[k].
      Sprawdzić czy przegra szybciej niz najlepszy wynik do tej pory.
  */

  int i, j, k, p;
  CyklMaszyny *cm;
  long long *tsum = new long long[n];
  long long *tmins = new long long[n];
  Start *st = new Start[n];

  // wyznaczenie zmian w cyklu maszyny
  cm = new CyklMaszyny[n];
  for (i = 0; i < n; ++i) {
    cm[i].wygr = cm[i].minw = 0;
    for (p = i; p < m; p += n) {
      cm[i].wygr += (a[p] == 'W' ? 1 : - 1);
      if (cm[i].wygr < cm[i].minw) cm[i].minw = cm[i].wygr;
    }
    cm[i].i = (i - m % n + n) % n;
    cm[i].ok = false;
  }

  #ifdef DBG_S
  printf("cykle maszyny\n");
  for (i = 0; i < n; ++i) printf("  %d->%d sum=%I64d minw=%I64d\n", i, cm[i].i, cm[i].wygr, cm[i].minw);
  #endif // DBG_S

  // wyznaczenie dużych cykli
  vector<DuzyCykl> cd;
  int nrc = 0;
  for (i = 0; i < n; ++i) if (!cm[i].ok) {
    DuzyCykl c;
    c.ti = vector<int>();
    //c.wygr = 0;
    for (p = i, j = 0; !cm[p].ok; p = cm[p].i, ++j) {  // dołączaj kolejne cykle maszyny
      cm[p].ok = true;
      c.ti.push_back(p); // pozycja początkowa chłopca
      //c.wygr += cm[p].wygr;
      tsum[j] = cm[p].wygr;
      tmins[j] = cm[p].minw;
      st[p].nrc = nrc;  // przypisanie pozycji początkowej chłopca do dużego cyklu
      st[p].i = j;      // numer kolejny pozycji pocz. chłopca w dużym cyklu
      #ifdef DBG_S
      printf("%d bedzie %d w cyklu %d\n", p, j, nrc);
      #endif // DBG_S
    }
    c.d = DP<int, long long>(0, c.ti.size() - 1, tsum, tmins);
    cd.push_back(c); // nowy duży cykl
    nrc++;
  }

  #ifdef DBG_S
  printf("duze cykle\n");
  for (i = 0; i < cd.size(); ++i) {
    printf("%d wygr=%I64d [", i, cd[i].wygr);
    for (j = 0; j < cd[i].ti.size(); ++j) printf("%d ", cd[i].ti[j]);
    printf("]\n");
    print(cd[i].d);
  }
  #endif // DBG_S

  long long wyn = -1;
  for (k = 0; k < n; ++ k) {
    #ifdef DBG_0
    if(k % 10000 == 0) printf("%d\n", k);
    #endif // DBG
    long long gry = 0; // liczba gier tego chłopca do przegranej
    nrc = st[k].nrc; // numer dużego cyklu
    i = st[k].i;     // numer kolejny pozycji chłopca w dużym cyklu
    int d = cd[nrc].ti.size(); // długość dużego cyklu
    long long mins, mins2;  // minimalna wygrana narastająco w dużym cyklu od pozycji chłopca
    long long sum, sum2;
    #ifdef DBG
    printf("k=%d i=%d nrc=%d d=%d kasa=%d\n", k, i, nrc, d, b[k]);
    #endif // DBG
    if (i == 0) {
      cd[nrc].d.GetMinW(0, d - 1, mins, sum);
    }
    else {
      cd[nrc].d.GetMinW(i, d - 1, mins, sum);
      cd[nrc].d.GetMinW(0, i - 1, mins2, sum2);
      #ifdef DBG
      printf("    %I64d %I64d %I64d %I64d\n", sum, mins, sum2, mins2);
      #endif // DBG
      mins = min(mins, sum + mins2);
      sum += sum2;
    }
    #ifdef DBG
    printf("  sum=%I64d mins=%I64d\n", sum, mins);
    #endif // DBG

    //Przegra jeśli: min wygrana narastająco w jego dużym cyklu <= -b[k] LUB suma wygranych w dużym cyklu < 0.
    if (!(mins <= -b[k] || sum < 0)) continue; //nie przegra
    // jeśli przegra to mins < 0

    // Wyznaczyć najmniejszą liczbę dużych cykli q, że min wygrana narastająco w dużym cyklu <= -(b[k] + q * suma wygranych w dużym cyklu)
    int q;
    if (b[k] <= -mins)
      q = 0;
    else
      q = (b[k] - 1 + min(0LL, (mins - sum))) / (-sum); // kasa minus (max przegrana poniżej sumy w cyklu) to "rezerwa" pozwalająca przechodzić kolejne całe cykle
    gry += ((long long)q * d) * m; // całe cykle, które przeżył
    b[k] += q * sum;  // ile przegrał
    #ifdef DBG
    printf("  d.cykle=%d, gry=%I64d, kasa=%d\n", q, gry, b[k]);
    #endif // DBG

    // Wyznaczyć najmniejszy numer cyklu maszyny w dużym cyklu dla którego min wygrana narastająco do tego cyklu włącznie jest <= -b[k]
    // Czyli ile cykli maszyny (q) przeżył w ramach dużego cyklu. Musi się znaleźć bo wiadomo, że już teraz przegra.
    // Przy okazji wyznaczyć ile przegra we wcześniejszych cyklach maszyny (sum) oraz numer cyklu w którym przegra (j)
    // Uwaga sum zawiera też wartość z cyklu w którym przegra i to trzeba odjąć.
    if (i == 0) {
      q = j = cd[nrc].d.FindMinW(0, d - 1, -b[k], sum);
    }
    else {
      j = cd[nrc].d.FindMinW(i, d - 1, -b[k], sum);
      if (j != -1) {
        #ifdef DBG
        printf("  1.znalezione w %d..%d  j=%d\n", i, d - 1, j);
        #endif // DBG
        q = j - i;
      }
      else { // nie przegrał w końcówce cyklu i patrzymy jeszcze na początek uwzględniając, że już przegrał sum
        j = cd[nrc].d.FindMinW(0, i - 1, -(b[k] + sum), sum2);
        #ifdef DBG
        printf("  2.znalezione w %d..%d  j=%d\n", 0, i - 1, j);
        #endif // DBG
        q = d - i + j;
        sum += sum2; // doliczamy co przegrał
      }
    }

    gry += (long long)q * m;  // całe cykle maszyny, które przeżył
    b[k] += (sum - cd[nrc].d.vals[j]);   // ile przegrał (odejmując z j-tego cyklu w którym przegrał bo całego nie rozegrał)
    #ifdef DBG
    printf("  m.cykle=%d, gry=%I64d, j=%d, sum=%I64d, kasa=%d\n", q, gry, j, sum, b[k]);
    #endif // DBG

    // Symulować kolejne gry chłopca dopóki b[k] > 0
    p = (k - ((long long) q * m) % n + n) % n; // zmiana pozycji chłopca w ciągu q cykli maszyny
    gry += p; // musi się doczekać aby być pierwszy
    while (true) {
      if (p < m) b[k] += a[p] == 'W' ? 1 : -1;
      #ifdef DBG
      printf("    p=%d, gry=%I64d, kasa=%d\n", p, gry, b[k]);
      #endif // DBG
      if (b[k] <= 0) {   // <= tylko aby się zatrzymało przy bugu
        gry++; // przegrał w tej grze
        break;
      }
      else {
        gry += n;
        p = (p + n) % m;
      }
    }

    #ifdef DBG
    printf("  gry=%I64d, kasa=%d\n", gry, b[k]);
    #endif // DBG
    if (wyn == -1 || gry < wyn) wyn = gry;

    if(gry < 0) {
      printf("k=%d\n", k);
      return -1;
    }
  }

  return wyn;
}

int main()
{
  czytaj();
  long long wyn = licz();
  printf("%lld\n", wyn);

  return 0;
}