四维dp（codeforces 132C - Logo Turtle）

C. Logo Turtle

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").

You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?

Input

The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".

The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.

Output

Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.

Sample test(s)

input

FT
1

output

2

input

FFFTFFF
2

output

6

Note

In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.

In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.

题意:F表示向前走，T表示向后转，有N次修改字符的机会，问最多能走多远

思路：dp[i][j][k][l]表示前i个字符修改了j次，走了k长度，当前朝向是l的状态能不能到达

具体详见代码

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=110;
char s[maxn];
int N;
int dp[110][55][220][2];
int main()
{
    while(scanf("%s",s+1)!=EOF)
    {
        scanf("%d",&N);
        int len=strlen(s+1);
        memset(dp,0,sizeof(dp));
        dp[0][0][len][0]=1;
        for(int i=1;i<=len;i++)
        {
            for(int j=0;j<=N;j++)
            {
                for(int k=0;k<=(len<<1);k++)
                {
                    for(int l=0;l<2;l++)
                    {
                        int pos;
                        if(s[i]=='T')
                        {
                            pos=k+(l==0?-1:1);
                            //接受当前的T，也就是这一步要转身成方向l，那么需要前一个字符方向l^1的状态存在
                            if(dp[i-1][j][k][l^1])dp[i][j][k][l]=1;
                            //如果要修改这个T，那么要求前i-1个字符修改过j-1次，因为是修改T，所以方向不变
                            else if(j>0&&pos>=0&&pos<=(len<<1)&&dp[i-1][j-1][pos][l])
                                dp[i][j][k][l]=1;

                        }
                        else
                        {
                            pos=k+(l==0?-1:1);
                            if(pos>=0&&pos<=(len<<1)&&dp[i-1][j][pos][l])
                                dp[i][j][k][l]=1;
                            else if(j>0&&dp[i-1][j-1][k][l^1])
                                dp[i][j][k][l]=1;
                        }
                    }
                }
            }
        }
        int ans=0;
        for(int j=N;j>=0;j-=2)
        {
            for(int k=0;k<=(len<<1);k++)
            {
                for(int l=0;l<2;l++)
                    if(dp[len][j][k][l])
                    ans=max(ans,abs(k-len));
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}