codeforces 1096D Easy Problem dp

D. Easy Problem

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Vasya is preparing a contest, and now he has written a statement for an easy problem. The statement is a string of length nn consisting of lowercase Latin latters. Vasya thinks that the statement can be considered hard if it contains a subsequence hard; otherwise the statement is easy. For example, hard, hzazrzd, haaaaard can be considered hard statements, while har, hart and drah are easy statements.

Vasya doesn't want the statement to be hard. He may remove some characters from the statement in order to make it easy. But, of course, some parts of the statement can be crucial to understanding. Initially the ambiguity of the statement is 00, and removing ii-th character increases the ambiguity by aiai (the index of each character is considered as it was in the original statement, so, for example, if you delete character r from hard, and then character d, the index of d is still 44 even though you delete it from the string had).

Vasya wants to calculate the minimum ambiguity of the statement, if he removes some characters (possibly zero) so that the statement is easy. Help him to do it!

Recall that subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.

Input

The first line contains one integer nn (1≤n≤1051≤n≤105) — the length of the statement.

The second line contains one string ss of length nn, consisting of lowercase Latin letters — the statement written by Vasya.

The third line contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤9982443531≤ai≤998244353).

Output

Print minimum possible ambiguity of the statement after Vasya deletes some (possibly zero) characters so the resulting statement is easy.

Examples

input

Copy

6
hhardh
3 2 9 11 7 1

output

Copy

5

input

Copy

8
hhzarwde
3 2 6 9 4 8 7 1

output

Copy

4

input

Copy

6
hhaarr
1 2 3 4 5 6

output

Copy

0

题目大意：输入一个字符串s，每个字符s[i]有一个权重a[i]表示移除该字符的代价，现求使得字符串s不含有'hard'子序列所需要的最小代价和。

dp[i][1]：表示字符串s的前i个字符中不含有前缀'h'的最小代价

dp[i][2]：表示字符串s的前i个字符中不含有前缀'ha'的最小代价

dp[i][3]：表示字符串s的前i个字符中不含有前缀'har'的最小代价

dp[i][4]：表示字符串s的前i个字符中不含有前缀'hard'的最小代价

对于状态转移，例如对dp[i][3]，如果位置i的字符不是r，那么dp[i][3] = dp[i - 1][3]；否则，要么去掉位置i的字符，则代价为dp[i - 1][3] + a[i]，如果不去除该位置字符，那么之前的序列不能含有'ha'，则代价为dp[i - 1][2]。

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#define ll long long
const int N = 1e5 + 10;
ll dp[N][5], a[N];
const ll INF = 1e15;
char s[N];
char ob[] = "xhard";
int n;
int main() {
    scanf("%d", &n);
    scanf("%s", s + 1);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i <= n; i++)  dp[i][0] = INF;
     if (s[1] == 'h') dp[1][1] = a[1]; 
    for (int i = 2; i <= n; i++) 
        for (int j = 1; j <= 4; j++) {
            if (s[i] != ob[j]) {
                dp[i][j] = dp[i - 1][j];
                continue;
            }
            dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j] + a[i]);
        }
    printf("%lld\n", dp[n][4]);
    return 0;
}