hdu6017

题意：
话的长度为n，语句里的字符不是2就是3。
呃喵的智力非常有限，只有m点。她每次操作可以交换两个相邻的字符，然而代价是智力-2。
现在问你，在使得自己智力不降为负数的条件下，呃喵最多能使这个字符串中有多少个子串”233”呢？
如”2333”中有一个”233”，”232323”中没有”233”
1 <= n <= 100, 0 <= m <= 100

#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<iostream>
#define N 110
#define M 35
#define inf 999
using namespace std;
int f[N][N][M][3][3],g[N][M],n,m,ans;
char s[N];
void upd(int &x,int y)
{
    if(x>y) x=y;
}
int main()
{
    int z;scanf("%d",&z);
    while(z--)
    {
        scanf("%d%d",&n,&m);m/=2;
        scanf("%s",s+1);
        if(n<3) {printf("0\n");continue;}
        for(int i=1;i<=n;i++)
            for(int j=0;j<=i;j++)
                for(int k=0;k<=n/3;k++)
                    for(int o1=0;o1<=2;o1++)
                        for(int o2=0;o2<=2;o2++)
                            f[i][j][k][o1][o2]=inf;
        if(s[1]=='2') f[1][0][0][0][2]=0;
        else f[1][0][0][2][0]=0;
        for(int i=1;i<n;i++)
        {
            int lim=i/3;
            for(int j=0;j<=i;j++)
                for(int k=0;k<=lim+1;k++)
                    g[j][k]=inf;
            for(int j=0;j<i;j++)
                for(int k=0;k<=lim;k++)
                    for(int o1=0;o1<=2;o1++)
                        for(int o2=0;o2<=2;o2++)
                        {
                            if(f[i][j][k][o1][o2]>m) f[i][j][k][o1][o2]=inf;
                            if(f[i][j][k][o1][o2]==inf) continue;
                            if(s[i+1]=='2')
                            {
                                if(o1==0)
                                {
                                    upd(f[i+1][j][k][o1][o2],f[i][j][k][o1][o2]);
                                    continue;
                                }
                                upd(f[i+1][i][k][0][o1],f[i][j][k][o1][o2]);
                                if(j)
                                {
                                    if(i-j<3) continue;
                                    upd(f[i+1][i][k][1][0],f[i][j][k][o1][o2]+1);
                                    if(i-j==3) continue;
                                    upd(g[j+3][k+1],f[i][j][k][o1][o2]);
                                }
                                else
                                {
                                    upd(f[i+1][i][k][1][0],f[i][j][k][o1][o2]+1);
                                    if(i>=2) upd(g[1][k+1],f[i][j][k][o1][o2]);
                                }
                            }
                            else
                            {
                                if(o1==1 || o1==2)
                                {
                                    if(o1==1) upd(f[i+1][j][k+1][2][0],f[i][j][k][o1][o2]);
                                    else upd(f[i+1][j][k][2][0],f[i][j][k][o1][o2]);
                                    continue;
                                }
                                upd(f[i+1][i][k][1][0],f[i][j][k][o1][o2]);
                                if(o2==1) upd(f[i+1][j+1][k+1][0][2],f[i][j][k][o1][o2]+i-j);
                                if(j+2<=i) upd(g[j+2][k],f[i][j][k][o1][o2]);
                            }
                        }
            int ed=i;
            if(s[i+1]=='2') ed=i-1;
            for(int k=0;k<=lim+1;k++)
            {
                int t=inf;
                for(int j=0;j<=ed;j++)
                {
                    upd(t,g[j][k]);
                    if(t!=inf)
                    {
                        if(s[i+1]=='2') upd(f[i+1][j][k][2][0],t+i+1-j);
                        else upd(f[i+1][j][k][0][1],t+i+1-j);
                    }
                }
            }
        }
        ans=0;
        for(int k=0;k<=n/3;k++)
            for(int j=0;j<n;j++)
                for(int o1=0;o1<=2;o1++)
                    for(int o2=0;o2<=2;o2++)
                        if(f[n][j][k][o1][o2]<=m) 
                            ans=k;
        printf("%d\n",ans);
    }
    return 0;
}

题解：
一看到正解是$O(n^4)$的吓得赶紧写一篇题解
首先要发现两个性质
1、所有的操作方式都能只用前移完成
2、交换后同种字符间的相对顺序不会改变
考虑dp，根据性质1转移时可以只用位置i前移得到所有状态
最暴力的状态是f[i][s][k]，表示处理了前i个位置，串长的样子是s，得到k个233最少交换几次。
根据性质2，假设s[i+1]为2，那他最终移动到的位置不会比上一个2要前，所以我们不需要记录整个串长什么样子，只需要记录上一个2出现的位置即可。3也是同理。
那么状态就变成了f[i][j1][j2][k]，j1和j2分别表示2和3上一次出现位置。再观察发现j1和j2必定有一个是i，所以可以省掉一维。
最终状态就是f[i][j][k][o1][o2]。表示考虑了前i位，上一个与第i位不同的字符在位置j，匹配出k个233，第i位为o1，第j位为o2最少交换几次。o1，o2的取值为0,1,2。0表示这是一个2。1表示这是一个3，并且在他后面加一个3可以贡献答案。2就表示不能贡献答案的3。
考虑转移，枚举新加入的位转移到哪个位置很容易，但是$O(n^4)$不稳啊。。
观察一下，发现枚举位置转移一个非常辣鸡的地方在于，他做了很多重复的转移，比如：

枚举i+1这个2要转移到中间那一段时，转移的状态其实都是f[i+1][j1][k+1][2][0]。而且考虑一下把这个2换到前面，破坏一个答案肯定不是最优的。所以特殊的转移只有换一次换到位置i。而中间一段同样的转移，用个数组记录，最后扫一遍就好了。
分析一下3的转移，也有类似的浪费，同样的方法处理即可。
于是复杂度就将到$O(n^3)$辣~~
就是写起来有点恶心