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 999using 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(n4)的吓得赶紧写一篇题解
首先要发现两个性质
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(n4)不稳啊。。
观察一下，发现枚举位置转移一个非常辣鸡的地方在于，他做了很多重复的转移，比如：

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