#include <iostream>
#include <string>
#include <cctype>
#include <vector>
#include <algorithm>

#define SIZE_OF_ARRAY(x) (sizeof(x) / sizeof(*(x)))

#ifndef _MSC_VER
#define __int64 long long
#endif

typedef unsigned int uint;
typedef unsigned __int64 uint64;

static char get_char_buffer[4 * 1024];
static std::size_t get_char_buffer_i = SIZE_OF_ARRAY(get_char_buffer);
static std::size_t get_char_buffer_n = SIZE_OF_ARRAY(get_char_buffer);

static char get_char_prefix = 0;
static char get_char_result = 0;

int get_char()
{
	get_char_result = 0;

	if (get_char_prefix)
	{
		get_char_result = get_char_prefix;

		get_char_prefix = 0;
	}
	else if (get_char_buffer_n == 0)
	{
		get_char_result = std::char_traits<char>::eof();
	}
	else if (get_char_buffer_i < get_char_buffer_n)
	{
		get_char_result = get_char_buffer[get_char_buffer_i++];
	}
	else
	{
		std::cin.read(get_char_buffer, SIZE_OF_ARRAY(get_char_buffer));

		get_char_buffer_i = 0;
		get_char_buffer_n = std::cin.gcount();

		return get_char();
	}

	return get_char_result;
}

void unget_char()
{
	get_char_prefix = get_char_result;
}

uint get_uint()
{
	int c;
	while (isspace(c = get_char()));

	uint value = (c - '0');

	while (isdigit(c = get_char()))
	{
		value = (10 * value) + (c - '0');
	}

	return value;
}

typedef std::vector<int> int_vector;
typedef std::vector<int_vector> int_vector_vector;

uint cash[1000004];
uint diff[1000004];

uint pos_to_cycle[1000004];
uint pos_in_cycle[1000004];

struct cycle_data
{
	uint pos;
	int diff;

	cycle_data() {};
	cycle_data(uint _pos) : pos(_pos) {};
};

typedef std::vector<cycle_data> cycle_data_vector;

cycle_data_vector cycle[1000004];
int cycle_min_diff[1000004];
int cycle_max_diff[1000004];

int_vector_vector pos_diff_idx[1000004];

int main()
{
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(0);

	uint n = get_uint();

	uint min_cash = 1000000;

	for (uint i = 0; i < n; ++i)
	{
		cash[i] = get_uint();
	}

	uint m = get_uint();

	while (isspace(get_char())); unget_char();

	for (uint i = 0; i < m; ++i)
	{
		diff[i] = (get_char() == 'P') ? -1 : 1;
	}

	uint cycle_id = 0;

	for (uint i = 0; i < m; ++i)
	{
		if (pos_to_cycle[i]) continue;

		uint k = 0;

		cycle[++cycle_id].push_back(cycle_data(i));
		pos_to_cycle[i] = cycle_id;
		pos_in_cycle[i] = k;

		for (uint j = (i + n) % m; j != i; j = (j + n) % m)
		{
			cycle[cycle_id].push_back(cycle_data(j));
			pos_to_cycle[j] = cycle_id;
			pos_in_cycle[j] = ++k;
		}

		int pos_diff = 0;
		int min_diff = 0;
		int max_diff = 0;

		for (auto &c_data : cycle[cycle_id])
		{
			c_data.diff = (pos_diff += diff[c_data.pos]);

			if (pos_diff < min_diff)
			{
				min_diff = pos_diff;
			}

			if (pos_diff > max_diff)
			{
				max_diff = pos_diff;
			}
		}

		cycle_min_diff[cycle_id] = min_diff;
		cycle_max_diff[cycle_id] = max_diff;
	}

	uint cycles = cycle_id;

	for (cycle_id = 1; cycle_id <= cycles; ++cycle_id)
	{
		int min_diff = cycle_min_diff[cycle_id];
		int max_diff = cycle_max_diff[cycle_id];

		uint cycle_diff_range = max_diff - min_diff + 1;

		cycle_data_vector &c = cycle[cycle_id];

		pos_diff_idx[cycle_id] = int_vector_vector(cycle_diff_range);

		for (uint c_i = 0; c_i < c.size(); ++c_i)
		{
			cycle_data &c_data = c[c_i];

			int pos_diff = c_data.diff - min_diff;

			pos_diff_idx[cycle_id][pos_diff].push_back(c_i);
		}
	}

	uint64 min_t = uint64(-1);

	for (uint i = 0; i < n; ++i)
	{
		int cash_i = cash[i];

		cycle_id = pos_to_cycle[i % m];
		cycle_data_vector &c = cycle[cycle_id];

		int min_diff = cycle_min_diff[cycle_id];
		if (min_diff >= 0) continue;

		uint k = pos_in_cycle[i % m];

		uint64 t = i;

		int diff_k = (k > 0) ? c[k - 1].diff : 0;

		int find_diff = diff_k - cash_i;

		int pos_diff = find_diff - min_diff;

		int_vector_vector &cycle_pos_diff_idx = pos_diff_idx[cycle_id];

		if (pos_diff >= 0 && pos_diff < int(cycle_pos_diff_idx.size()))
		{
			int_vector &idx = cycle_pos_diff_idx[pos_diff];

			auto it = std::upper_bound(idx.begin(), idx.end(), int(k) - 1);

			if (it != idx.end())
			{
				uint c_i = *it;

				t += uint64(c_i - k) * n + 1;

				if (t < min_t)
				{
					min_t = t;
				}

				continue;
			}
		}

		t += uint64(c.size() - k) * n;

		cash_i += c.back().diff - ((k > 0) ? c[k - 1].diff : 0);


		int cash_full = cash_i + min_diff;

		if (cash_full <= 0)
		{
			int pos_cash_diff = -cash_i - min_diff;

			t += uint64(pos_diff_idx[cycle_id][pos_cash_diff].front()) * n + 1;

			if (t < min_t)
			{
				min_t = t;
			}

			continue;
		}

		int full_diff = c.back().diff;

		if (full_diff >= 0)
		{
			continue;
		}

		int full_cycles = cash_full / -full_diff;

		t += uint64(c.size()) * full_cycles * n;

		cash_i += full_diff * full_cycles;


		while (cash_i + min_diff > 0)
		{
			t += uint64(c.size()) * n;

			cash_i += full_diff;
		}

		if (cash_i > 0)
		{
			int pos_cash_diff = -cash_i - min_diff;

			t += uint64(pos_diff_idx[cycle_id][pos_cash_diff].front()) * n + 1;
		}
		else
		{
			t -= uint64(n) - 1;
		}

		if (t < min_t)
		{
			min_t = t;
		}
	}

	if (min_t == uint64(-1))
	{
		std::cout << "-1\n";
	}
	else
	{
		std::cout << min_t << '\n';
	}

	return 0;
}