HDU 6212 区间DP

简略题意：给出一个01串，连续相同的数大于等于3个可以消除。你可以任意在某个位置插入01，问至少插入多少个01能够使得原串被完全消除。

n只有200，答案要求最优解，那么可以考虑区间dp的套路。
定义dp[l][r]代表将区间[l, r]都消除之后的最小代价，枚举转移i，复杂度O(n^3)。

考虑转移，我们能做的事情是什么？
对某个位置插入01，使得这段被消除。
1. 枚举切除位置，将原有部分从中间切开成两半，彼此消除不干扰。
① $dp[l][r] = min(dp[l][i] + dp[i+1][r])$。

2.对于[l, r]区间，假若我们把中间的部分消除了，就可以使得两边的相同的数再次被消除。
例如:0010，如果我们把1消除了，那么000就可以连接到一起然后被消除。这也提醒了我们对原串压缩之后可以方便操作，把相同连续的数给压缩成1组，记录组内的个数，这样每两个相邻的组的数都不相同。压缩完之后就可以直接对组进行区间DP。

Change!

定义$v[i]$为第i组内数的个数，我们直接对组进行$dp$。
转变思想之后，第一类转移依旧不变。
① $dp[l][r] = min(dp[l][i] + dp[i+1][r])$。
对于第二类，只有$[l, r]$区间长度为奇数，才可以转移。因为只有这样才能保证v[l]和v[r]对应的是同一类数。
② $dp[l][r] = dp[l+1][r-1] + (v[l] + v[r]) == 2)$。
因为$v[l] + v[r] >= 2$，若等于2，则说明我们还需要插入一个才能消除，否则就可以直接消除了。

3.左侧一块，中间一块，右侧一块，这样我们把左半的障碍物，右半的障碍物都给消除之后，这三部分组成一块消除。
③ $dp[l][r] = min(dp[l+1][i-1] + dp[i+1][r])$。
<1>这种转移只有在中间这块大小为1才行，否则无论左右数量是多少，还没等到把两部分障碍物都消除完，就已经被消除了。
<2>这种转移也得确保左右两块大小不能同时大于等于2，假若左侧大小为1，右侧大小为2，那么我们可以先消除左半的障碍物，然后消除右半的障碍物之后就可以同时消除4个。否则理由同<1>。

那么还有第4种转移吗？
可以发现不存在同时消除大于等于5个的情况，因为在聚集之前就会被分解成3+2或者4+1的情况。
嘿嘿，虽然是老题，但是有趣就可以了不是吗=v=

#define others
#ifdef poj
#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#endif // poj
#ifdef others
#include <bits/stdc++.h>
#endif // others
//#define file
#define all(x) x.begin(), x.end()
using namespace std;
const long double eps = 1e-8;
//int dcmp(long double x) { if(_abs(x)<=eps) return 0; return (x>0)?1:-1;};
typedef long long LL;

namespace fastIO{
    #define BUF_SIZE 100000
    #define OUT_SIZE 100000
    #define ll long long
    //fread->read
    bool IOerror=0;
    inline char nc(){
        static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
        if (p1==pend){
            p1=buf; pend=buf+fread(buf,1,BUF_SIZE,stdin);
            if (pend==p1){IOerror=1;return -1;}
            //{printf("IO error!\n");system("pause");for (;;);exit(0);}
        }
        return *p1++;
    }
    inline bool blank(char ch){return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';}
    inline int read(int &x){
        bool sign=0; char ch=nc(); x=0;
        for (;blank(ch);ch=nc());
        if (IOerror)return 0;
        if (ch=='-')sign=1,ch=nc();
        for (;ch>='0'&&ch<='9';ch=nc())x=x*10+ch-'0';
        if (sign)x=-x;
        return 1;
    }
    inline int read(ll &x){
        bool sign=0; char ch=nc(); x=0;
        for (;blank(ch);ch=nc());
        if (IOerror)return 0;
        if (ch=='-')sign=1,ch=nc();
        for (;ch>='0'&&ch<='9';ch=nc())x=x*10+ch-'0';
        if (sign)x=-x;
        return 1;
    }
    inline int read(long double &x){
        bool sign=0; char ch=nc(); x=0;
        for (;blank(ch);ch=nc());
        if (IOerror)return 0;
        if (ch=='-')sign=1,ch=nc();
        for (;ch>='0'&&ch<='9';ch=nc())x=x*10+ch-'0';
        if (ch=='.'){
            long double tmp=1; ch=nc();
            for (;ch>='0'&&ch<='9';ch=nc())tmp/=10.0,x+=tmp*(ch-'0');
        }
        if (sign)x=-x;
        return 1;
    }
    inline int read(char *s){
        char ch=nc();
        for (;blank(ch);ch=nc());
        if (IOerror)return 0;
        for (;!blank(ch)&&!IOerror;ch=nc())*s++=ch;
        *s=0;
        return 1;
    }
    inline void read(char &c){
        for (c=nc();blank(c);c=nc());
        if (IOerror){c=-1;return;}
    }
    //fwrite->write
    struct Ostream_fwrite{
        char *buf,*p1,*pend;
        Ostream_fwrite(){buf=new char[BUF_SIZE];p1=buf;pend=buf+BUF_SIZE;}
        void out(char ch){
            if (p1==pend){
                fwrite(buf,1,BUF_SIZE,stdout);p1=buf;
            }
            *p1++=ch;
        }
        void print(int x){
            static char s[15],*s1;s1=s;
            if (!x)*s1++='0';if (x<0)out('-'),x=-x;
            while(x)*s1++=x%10+'0',x/=10;
            while(s1--!=s)out(*s1);
        }
        void println(int x){
            static char s[15],*s1;s1=s;
            if (!x)*s1++='0';if (x<0)out('-'),x=-x;
            while(x)*s1++=x%10+'0',x/=10;
            while(s1--!=s)out(*s1); out('\n');
        }
        void print(ll x){
            static char s[25],*s1;s1=s;
            if (!x)*s1++='0';if (x<0)out('-'),x=-x;
            while(x)*s1++=x%10+'0',x/=10;
            while(s1--!=s)out(*s1);
        }
        void println(ll x){
            static char s[25],*s1;s1=s;
            if (!x)*s1++='0';if (x<0)out('-'),x=-x;
            while(x)*s1++=x%10+'0',x/=10;
            while(s1--!=s)out(*s1); out('\n');
        }
        void print(long double x,int y){
            static ll mul[]={1,10,100,1000,10000,100000,1000000,10000000,100000000,
                1000000000,10000000000LL,100000000000LL,1000000000000LL,10000000000000LL,
                100000000000000LL,1000000000000000LL,10000000000000000LL,100000000000000000LL};
            if (x<-1e-12)out('-'),x=-x;x*=mul[y];
            ll x1=(ll)floor(x); if (x-floor(x)>=0.5)++x1;
            ll x2=x1/mul[y],x3=x1-x2*mul[y]; print(x2);
            if (y>0){out('.'); for (size_t i=1;i<y&&x3*mul[i]<mul[y];out('0'),++i); print(x3);}
        }
        void println(long double x,int y){print(x,y);out('\n');}
        void print(char *s){while (*s)out(*s++);}
        void println(char *s){while (*s)out(*s++);out('\n');}
        void flush(){if (p1!=buf){fwrite(buf,1,p1-buf,stdout);p1=buf;}}
        ~Ostream_fwrite(){flush();}
    }Ostream;
    inline void print(int x){Ostream.print(x);}
    inline void println(int x){Ostream.println(x);}
    inline void print(char x){Ostream.out(x);}
    inline void println(char x){Ostream.out(x);Ostream.out('\n');}
    inline void print(ll x){Ostream.print(x);}
    inline void println(ll x){Ostream.println(x);}
    inline void print(long double x,int y){Ostream.print(x,y);}
    inline void println(long double x,int y){Ostream.println(x,y);}
    inline void print(char *s){Ostream.print(s);}
    inline void println(char *s){Ostream.println(s);}
    inline void println(){Ostream.out('\n');}
    inline void flush(){Ostream.flush();}
};
using namespace fastIO;

long double _abs(long double x) {
    return x<0?-x:x;
}

namespace solver {
    int dp[222][222];
    int t, n;
    string str;
    int v[222], id;
    void solve() {
        int f = 0;
        cin >> t;
        while(t--) {
            memset(dp, -1, sizeof dp);
            cin >> str;
            id = 0;
            n = str.size();
            memset(v, 0, sizeof v);
            for(int i = 0; i < n; i++) {
                if(i == 0 || str[i] != str[i-1])
                    v[++id] = 1;
                else
                    v[id]++;
            }
            memset(dp, 0x3f3f3f3f, sizeof dp);
            for(int len = 1; len <= id; len++) {
                for(int i = 1; i <= id; i++) {
                    int j = len + i - 1;
                    if(j > id) break;
                    if(len == 1) {
                        dp[i][j] = 3-v[i];
                    } else {
                        for(int k = i; k < j; k++)
                            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
                        if(len & 1) {
                            if(v[i] + v[j] == 2)
                                dp[i][j] = min(dp[i][j], dp[i+1][j-1] + 1);
                            else
                                dp[i][j] = min(dp[i][j], dp[i+1][j-1]);
                            if(v[i] + v[j] < 4) {
                                for(int k = i + 2; k < j; k+=2)
                                    if(v[k] == 1)
                                        dp[i][j] = min(dp[i][j], dp[i+1][k-1] + dp[k+1][j-1]);
                            }
                        }
                    }
                }
            }
            printf("Case #%d: %d\n", ++f, dp[1][id]);
        }
    }
}

int main() {
    solver::solve();
    return 0;
}