Codefroces: D. Easy Problem

题目链接：http://codeforces.com/contest/1096/problem/D

D. Easy Problem

time limit per test 2 seconds
memory limit per test 256 megabytes

problem Decription

Vasya is preparing a contest, and now he has written a statement for an easy problem. The statement is a string of length n

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 0
, and removing i-th character increases the ambiguity by ai (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 4

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 n(1≤n≤105) — the length of the statement.

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

The third line contains n integers a1,a2,…,an (1≤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
6
hhardh
3 2 9 11 7 1

Output
5

Input
8
hhzarwde
3 2 6 9 4 8 7 1

Output
4

Input
6
hhaarr
1 2 3 4 5 6

Output
0

Note

In the first example, first two characters are removed so the result is ardh.

In the second example, 5-th character is removed so the result is hhzawde.

In the third example there’s no need to remove anything.

解题心得：

1. 题意就是给你一个长度为n的字符串，你可以对字符进行删除，每个字符删除有个代价。要求你对字符删除之后不能出现hard的子序列。
2. 就是一个dp，因为不能出现hard，所以删除的只有四个字符h、a、r、d。如果从h开始转移就可能导致并不能出现hard但是删除了h、a、r等字符得到的代价是错误的，所以在dp的时候应该从d开始删除，如果可以删除d那么可以从d的状态上转移到r、a、d三个字符。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5+100;
typedef long long ll;

ll dp[8][maxn];
int num[maxn], n;

char s[maxn], aim[10] = "hard";

void init() {
    scanf("%d",&n);
    scanf("%s", s+1);
    for(int i=1;i<=n;i++) {
        scanf("%d", &num[i]);
    }

    for(int i=0;i<=3;i++) {
        for(int j=0;j<=n+1;j++) {
            dp[i][j] = 1e18;
        }
    }
}

void DP() {
    for(int j=n;j>=1;j--) {
        if(s[j] == aim[3]) {
            if(dp[3][j+1] == 1e18)
                dp[3][j] = num[j];
            else
                dp[3][j] = dp[3][j+1] + num[j];
        } else
            dp[3][j] = dp[3][j+1];
    }
    for(int i=2;i>=0;i--) {
        for(int j=n;j>=1;j--) {
            if(s[j] == aim[i] && dp[i+1][j] != 1e18) {
                if(dp[i][j+1] == 1e18)
                    dp[i][j] = min((long long)num[j], dp[i+1][j]);
                else
                    dp[i][j] = min(dp[i+1][j],dp[i][j+1] + num[j]);
            } else {
                dp[i][j] = dp[i][j + 1];
            }
        }
    }
}

int main() {
   // freopen("1.in", "r", stdin);

    init();
    DP();
    if(dp[0][1] == 1e18)
        dp[0][1] = 0;
    printf("%lld", dp[0][1]);
    return 0;
}