CodeForces1096D- Easy Problem（dp）

Description:
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.

题意：
给出一个长度为n的字符串s，以及删去每一位的代价ai，问使得字符串中不包含子串hard的最小代价是多少，子串hard不一定要连续。

解法：
这是一道dp题。设dp[i][j]为使得前i个位置形成的串不包含子串hard的前j位的最小代价，假如s[i]!=t[j]，意味着这一位无法做出贡献，所以dp[i][j]=dp[i-1][j]，假如s[i]==t[j]，意味着接下来有两种选择，一种是删掉s[i]，即dp[i][j]=dp[i-1][j]+ai，另一种是不删掉s[i]，要求前i-1个位置形成不包含子串hard的前j-1位的串，即dp[i][j]=dp[i-1][j-1]，此时从两种情况里取min即可。
方法来自https://blog.csdn.net/qq_40791842/article/details/90815700。

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stdlib.h>
#include<cstring>
#include<set>
using namespace std;

int n;
char t[5]={' ','h','a','r','d'};
char s[100000+5];
long long a[100000+5];
long long dp[100000+5][5+5];

int main()
{
    scanf("%d%s",&n,s+1);
    for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
    memset(dp,0x3f,sizeof(dp));
    dp[0][1]=dp[0][2]=dp[0][3]=dp[0][4]=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=4;j++){
            if(s[i]!=t[j])dp[i][j]=dp[i-1][j];
            else dp[i][j]=min(dp[i-1][j]+a[i],dp[i-1][j-1]);
        }
    }
    printf("%lld\n",dp[n][4]);
    return 0;
}