#ifdef LOCAL
#include <cstdio>
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstring>
#else
#include <bits/stdc++.h>
#endif
using namespace std ;

typedef long long ll ;
typedef unsigned long long ull ;
#define rep(i , n ) for ( int i =0; i < n ; i++)
#define rrep(i , n) for ( int i = n-1; i >=0 ; i--)

#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;

class UnionFind {
private:
	ull size_; 
	std::vector<ull> par, rank, count;

public:
	UnionFind() : size_(0), par(std::vector<ull>()), rank(std::vector<ull>()), count(std::vector<ull>()) {};
	UnionFind(ull size__) : size_(size__) {
		par.resize(size_); rank.resize(size_); count.resize(size__);
		for (ull i = 0; i < size_; i++) par[i] = i, rank[i] = 0, count[i] = 1;
	}
	ull size() { return size_; }
	// ull root(ull x) { return par[x] == x ? x : par[x] = root(par[x]); }
	
	ull root(ull x)
	{
		while(par[x] != x)
		{
			par[x] = par[par[x]];
			x = par[x];
		}
		return x;
	}
	
	bool same(ull x, ull y) { return root(x) == root(y); }

	void unite(ull x, ull y) {
		x = root(x), y = root(y);
		if (x == y) return;
		if (rank[x] < rank[y]) par[x] = y, count[y]+=count[x], count[x]=0;
		else if (rank[x] == rank[y]) par[y] = x, rank[x]++, count[x]+=count[y], count[y]=0;
		else par[y] = x, count[x] += count[y], count[y] = 0;
	}

	ull size__(ull x)
	{
		return count[root(x)];
	}

	bool operator==(const UnionFind &u) { return par == u.par; }
	bool operator!=(const UnionFind &u) { return par != u.par; }
};
/*
maybe sth wrong 
got wa in one problem
*/
ll modpow(ll a, ll b)
{
	if (b == 0)
	{
		return 1;
	}

	if (b % 2)
	{
		return a * modpow(a, b-1) % MOD;
	}
	else
	{
		ll halfB = b / 2;
		ll half = modpow(a, halfB);
		return half * half % MOD;
	}
}

ll calcComb(ll n, ll m)
{
	if (m > n-m)
	{
		return calcComb(n, n-m);
	}

	ll ansMul = 1;
	ll ansDiv = 1;

	rep(i, m)
	{
		ansMul *= (n-i);
		ansDiv *= (i+1);
		ansMul %= MOD;
		ansDiv %= MOD;
	}

	return ansMul * modpow(ansDiv, MOD - 2) % MOD;
}

__attribute__((constructor))
void initial()
{
	cin.tie(NULL);
	ios::sync_with_stdio(false);
}

#if 0
int main()
{
	ll n, k;
	cin >> n >> k;

	ll r, s, p;
	cin >> r >> s >> p;

	string t;
	cin >> t;

	#if 0
	ll dp[n+1][3] = {0};

	for (int i = 1; i <= n; i++)
	{
		if (i - k < 0)
		{
			if (t[i-1] == 'r')
			{
				// 0->r
				dp[i][0] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2]));
				// 1->s
				dp[i][1] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2]));
				// 2->p
				dp[i][2] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2])) + p;
			}
			else if (t[i-1] == 's')
			{
				// 0->r
				dp[i][0] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2])) + r;
				// 1->s
				dp[i][1] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2]));
				// 2->p
				dp[i][2] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2]));
			}

			else if (t[i-1] == 'p')
			{
				// 0->r
				dp[i][0] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2]));
				// 1->s
				dp[i][1] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2])) + s;
				// 2->p
				dp[i][2] = max(dp[i-1][0], max(dp[i-1][1], dp[i-1][2]));
			}
		}
		else
		{
			for (int j = 0; j < k; j++)
			{

			}
		}
	
	}
	#endif
	ll ans = 0;

	rep(i, k)
	{
		if (t[i] == 'r')
		{
			ans += p;
		}
		else if (t[i] == 's')
		{
			ans += r;
		}
		else if (t[i] == 'p')
		{
			ans += s;
		}
	}

	for (int j = k; j < n; j++)
	{
		if (t[j] == t[j-k])
		{
			t[j] = 0;
		}
		else
		{
			if (t[j] == 'r')
			{
				ans += p;
			}
			else if (t[j] == 's')
			{
				ans += r;
			}
			else if (t[j] == 'p')
			{
				ans += s;
			}
		}
		
	}
	cout << ans << endl;

	return 0;
}
#endif
long long solve(string T, long long R, long long S, long long P){
    int N = T.size();
    vector<vector<long long> > dp(3, vector<long long>(N));
    vector<int> v(N);
    rep(i, N)
        if(T[i] == 'r') v[i] = 0;
        else if(T[i] == 's') v[i] = 1;
        else v[i] = 2;
    long long points[3] = {P, R, S};
 
    dp[v[0]][0] = points[v[0]];
    for(int i=1; i<N; i++){
        int a = v[i];
        int b = (a+1)%3;
        int c = (a+2)%3;
        dp[a][i] = max(dp[b][i-1], dp[c][i-1])+points[v[i]];
        dp[b][i] = max(dp[a][i-1], dp[c][i-1]);
        dp[c][i] = max(dp[a][i-1], dp[b][i-1]);
    }
    long long ret = 0;
    rep(i, 3)
        ret = max(ret, dp[i][N-1]);
    return ret;
}
 
int main(){
    long long N, K, R, S, P;
    string T;
    cin >> N >> K;
    cin >> R >> S >> P;
    cin >> T;
 
    long long ans = 0;
    rep(i, K){
        string TT = "";
        for(int j=i; j<N; j+=K) TT += T[j];
        ans += solve(TT, R, S, P);
    }
    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 3712