简略题意:给出一个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;
}