【BZOJ4565】【HAOI2016】字符合并 [状压DP][区间DP]

字符合并

Time Limit: 20 Sec  Memory Limit: 256 MB
[Submit][Status][Discuss]

Description

　　有一个长度为 n 的 01 串，你可以每次将相邻的 k 个字符合并，得到一个新的字符并获得一定分数。

　　得到的新字符和分数由这 k 个字符确定。你需要求出你能获得的最大分数。

Input

　　第一行两个整数n，k。接下来一行长度为n的01串，表示初始串。

　　接下来2^k行，每行一个字符ci和一个整数wi，

　　ci表示长度为k的01串连成二进制后按从小到大顺序得到的第i种合并方案得到的新字符,

　　wi表示对应的第i种方案对应获得的分数。

Output

　　输出一个整数表示答案

Sample Input

　　3 2
　　101
　　1 10
　　1 10
　　0 20
　　1 30

Sample Output

　　40

HINT

　　1<=n<=300 ,0<=ci<=1, wi>=1, k<=8

Solution

　　我们显然考虑区间DP，再状态压缩一下，f[l][r][opt]表示[l, r]合成了opt的最大价值。

　　如果一个区间长度为len的话，最后合完会长度会变为len % (k - 1)。

　　转移的本质是把长度为k的区间变成0/1，分情况处理。

　　　　先枚举每一个断点pos，表示我们要把[pos, r]合成一个0/1，那么就要保证(r - pos + 1) % (k - 1) = 1，否则我们DP的时候，会把000看做是0一样转移，导致不能合成为一个0/1的合成了。

　　　　若len % (k -1) = 1，则合成完会剩下一个数，我们判断一下[l, r]能否合成一个opt的状态，若可以，则f[l][r][c[opt]] = max(f[l][r][opt] + val[opt])。注意要先拿一个变量记录下来，不能直接更新，否则会出现0状态更新了1，然后1又用0更新了的情况，导致答案过大。

　　最后答案显然就是max(f[1][n][opt])。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 using namespace std;
 typedef long long s64;
 
 const int ONE = ;
 const int MOD = 1e9 + ;
 
 int n, k;
 int total;
 int a[ONE];
 char s[ONE];
 int c[ONE], val[ONE];
 s64 f[ONE][ONE][ONE];
 s64 Ans;
 
 int get()
 {
         int res=,Q=;  char c;
         while( (c=getchar())< || c>)
         if(c=='-')Q=-;
         if(Q) res=c-;
         while((c=getchar())>= && c<=)
         res=res*+c-;
         return res*Q;
 }
 
 int main()
 {
         n = get();  k = get(); total = ( << k) - ;
 
         for(int i = ; i <= n; i++)
             for(int j = ; j <= n; j++)
                 for(int opt = ; opt <= total; opt++)
                     f[i][j][opt] = -;
 
         scanf("%s", s + );
         for(int i = ; i <= n; i++)
             a[i] = s[i] - '', f[i][i][a[i]] = ;
 
         for(int i = ; i <= total; i++)
             c[i] = get(), val[i] = get();
 
         for(int l = n; l >= ; l--)
             for(int r = l; r <= n; r++)
                 {
                     if(l == r) continue;
 
                     for(int pos = r - ; pos >= l; pos -= k - )
                         for(int opt = ; opt <= total; opt++)
                         {
                             if(f[l][pos][opt] == -) continue;
                             if(f[pos + ][r][] != - && (opt << ) <= total)
                                 f[l][r][opt << ] = max(f[l][r][opt << ], f[l][pos][opt] + f[pos + ][r][]);
                             if(f[pos + ][r][] != - && (opt <<  | ) <= total)
                                 f[l][r][opt <<  | ] = max(f[l][r][opt <<  | ], f[l][pos][opt] + f[pos + ][r][]);
                         }
 
                     if((r - l + ) % (k - ) ==  || k == )
                     {
                         s64 A = -, B = -;
                         for(int opt = ; opt <= total; opt++)
                             if(f[l][r][opt] != -)
                             {
                                 if(c[opt] == ) A = max(A, f[l][r][opt] + val[opt]);
                                 if(c[opt] == ) B = max(B, f[l][r][opt] + val[opt]);
                             }
 
                         f[l][r][] = max(f[l][r][], A);
                         f[l][r][] = max(f[l][r][], B);
                     }
                 }
 
         for(int opt = ; opt <= total; opt++)
             Ans = max(Ans, f[][n][opt]);
 
         printf("%lld", Ans);
 
 }
 

• 制作