1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class haz
{
	static class Gracz
	{
		private int oszczednosci = 0;
		private int oszczednosciPoJednymCyklu = 0;
		private int ilePrzegrywaPoJednymCyklu = 0;
		private String cykl = new String();
		private char ostatniZnak = ' ';
		private TreeSet<Integer> wejscieAbyPrzegral = new TreeSet<>();
		private int pom = 0;
		
		public Gracz(int oszczednosci_)
		{
			this.oszczednosci = oszczednosci_;
			this.oszczednosciPoJednymCyklu = oszczednosci_;
		}
	}
	
	static class Komparator implements Comparator<Integer>
	{
		@Override
		public int compare(Integer x, Integer y)
		{
			if(x == -1 && y == -1) return 0;
			if(x == -1 && y != -1) return 1;
			if(y == -1 && x != -1) return -1;
			return x < y ? -1 : (x == y ? 0 : 1);
		}
	}
	
	public static void main(String[] args)
	{
		Scanner skaner = new Scanner(System.in);
		int liczbaKolegow = 0, dlugoscCykluPracyAutomatu = 0;
		String cyklPracyAutomatu =  new String();
		Gracz[] gracze;
		TreeSet<Integer> kiedyKoniecGry = new TreeSet<>(new Komparator());
		
		if(skaner.hasNextInt()) liczbaKolegow = skaner.nextInt();
		gracze = new Gracz[liczbaKolegow];
		
		for(int i = 0; i < liczbaKolegow; i++)
		{
			if(skaner.hasNextInt()) gracze[i] = new Gracz(skaner.nextInt());
		}
		if(skaner.hasNextInt()) dlugoscCykluPracyAutomatu = skaner.nextInt();
		if(skaner.hasNext()) cyklPracyAutomatu = skaner.next();
		skaner.close();
		
		int i = 0, j = 0, gra = 1;
		do
		{
			char znak = cyklPracyAutomatu.charAt(j);
			gracze[i].cykl += znak;
			if(znak == 'W')
			{
				gracze[i].oszczednosciPoJednymCyklu++;
				if(gracze[i].ostatniZnak == 'P' && gracze[i].pom < 0)
					gracze[i].wejscieAbyPrzegral.add(Math.abs(gracze[i].pom));
				gracze[i].pom++;
				gracze[i].ostatniZnak = znak;
			}
			else
			{
				gracze[i].oszczednosciPoJednymCyklu--;
				if(gracze[i].wejscieAbyPrzegral.isEmpty() && gracze[i].pom < 0)
					gracze[i].wejscieAbyPrzegral.add(Math.abs(gracze[i].pom));
				gracze[i].pom--;
				gracze[i].ostatniZnak = znak;
			}
			if(gracze[i].oszczednosciPoJednymCyklu == 0)
			{
				System.out.println(gra);
				System.exit(0);
			}
			
			gra ++;
			i = (i+1)%liczbaKolegow;
			j = (j+1)%dlugoscCykluPracyAutomatu;
		}
		while(!(i == 0 && j == 0));
		
		int dlugoscCykluGraczy = gracze[0].cykl.length();
		
		for(int k = 0; k < gracze.length; k++)
		{
			Gracz gracz = gracze[k];
			if(gracz.oszczednosciPoJednymCyklu >= gracz.oszczednosci)
			{
				kiedyKoniecGry.add(-1);
				continue;
			}
			gracz.ilePrzegrywaPoJednymCyklu = gracz.oszczednosci - gracz.oszczednosciPoJednymCyklu;
			int pozostaleOszczednosci = gracz.oszczednosciPoJednymCyklu;
			int cykl = 2;
			while(!gracz.wejscieAbyPrzegral.contains(pozostaleOszczednosci) && pozostaleOszczednosci > gracz.ilePrzegrywaPoJednymCyklu)
			{
				pozostaleOszczednosci -= gracz.ilePrzegrywaPoJednymCyklu;
				cykl++;
			}
			int nrGry = 0, l = 0;
			while(pozostaleOszczednosci != 0)
			{
				if(gracz.cykl.charAt(l) == 'W') pozostaleOszczednosci++;
				else pozostaleOszczednosci --;
				nrGry++;
				l++;
			}
			kiedyKoniecGry.add(liczbaKolegow*dlugoscCykluGraczy*(cykl - 1) + liczbaKolegow*(nrGry - 1) + k + 1);
		}
		
		System.out.println(kiedyKoniecGry.first());
	}
}