CodeForces 83 E.Two Subsequences（状压DP）
Description
定义 01 01 串之间的映射 f f 满足以下四个条件：
1. f(NULL)=NULL f ( N U L L ) = N U L L
2. f(s)=s,s f ( s ) = s , s 为任意 01 01 串
3. f(s1,s2) f ( s 1 , s 2 ) 为以 s1 s 1 为前缀， s2 s 2 为后缀的最短 01 01 串
4.f(a1,...,an)=f(f(a1,...,an−1),an) 4. f ( a 1 , . . . , a n ) = f ( f ( a 1 , . . . , a n − 1 ) , a n )
先给出 n n 个等长的字符串 a1,...,an a 1 , . . . , a n ，要求把这些字符串分成两个子序列 b1,...,ak b 1 , . . . , a k 和 c1,...,cm c 1 , . . . , c m ，其中 k+m=n k + m = n ，使得 S=|f(b1,...,bk)+f(c1,...,cm)| S = | f ( b 1 , . . . , b k ) + f ( c 1 , . . . , c m ) | 最小，输出该最小值
Input
第一行一整数 n n 表示字符串个数，之后输入 n n 个等串长且串长不超过 20 20 的 01 01 串 (1≤n≤2⋅105) ( 1 ≤ n ≤ 2 ⋅ 10 5 )
Output
输出 S S 的最小值
Sample Input
3
01
10
01
Sample Output
4
Solution
依次考虑每个字符串的所属，假设当前考虑到第 i i 个字符串，那么前 i−1 i − 1 个字符串已经被分成了两个子序列，显然 ai−1 a i − 1 是某个子序列的末尾，或者说每次考虑的最后一个字符串必然为一个子序列的末尾，假设另一个序列末尾为 aj a j ，若 ai a i 跟在 ai−1 a i − 1 后面，那么 aj a j 依旧是另一个子序列的末尾，若 ai a i 跟在 aj a j 后面，那么 ai−1 a i − 1 变成另一个序列末尾，故不需要考虑另一个序列具体是哪一个字符串，只需要知道另一个序列末尾的状态即可
以 dp[i][j][k] d p [ i ] [ j ] [ k ] 表示前 i i 个字符串分好后，不以 ai a i 为结尾的子序列后 j j 位状态为 k k 时 S S 的最小值，那么根据 ai a i 的所属有转移：
1.若 ai a i 跟在 ai−1 a i − 1 后面，那么另一个序列后 j j 位的状态都不会改变，此时对 S S 值的影响为 ai−1 a i − 1 接上 ai a i 所增加的串长，也即 dp[i][j][k]+=len−deal(ai−1,ai) d p [ i ] [ j ] [ k ] + = l e n − d e a l ( a i − 1 , a i ) ，其中 len l e n 为每个字符串的串长， deal(x,y) d e a l ( x , y ) 表示求出 x x 的后缀与 y y 的前缀最长公共部分
2.若 ai a i 跟在另一个序列后面，那么此时的所谓的另一个序列变成以 ai−1 a i − 1 结尾，那么其末尾 j j 位状态即为 ai−1 a i − 1 后 j j 位的状态，记为 suf(ai−1,j) s u f ( a i − 1 , j ) ，而此时对 S S 值的影响是将 ai a i 接在了另一个子序列上，枚举另一个子序列末尾与 ai a i 的公共部分长度 k k 有转移：
dp[i][j][suf(ai−1,j)]=mink(dp[i−1][k][pre(ai,k)]+len−k) d p [ i ] [ j ] [ s u f ( a i − 1 , j ) ] = min k ( d p [ i − 1 ] [ k ] [ p r e ( a i , k ) ] + l e n − k )
其中 pre(ai,j) p r e ( a i , j ) 为 ai a i 前 j j 位状态
此时转移的复杂度为 O(n⋅len⋅2len) O ( n ⋅ l e n ⋅ 2 l e n ) ，但注意到，记 temp=len−deal(ai−1,ai) t e m p = l e n − d e a l ( a i − 1 , a i ) ，则第二种转移等价于
dp[i][j][suf(ai−1,j)]=mink(dp[i−1][k][pre(ai,k)]+len−k−temp)+temp d p [ i ] [ j ] [ s u f ( a i − 1 , j ) ] = min k ( d p [ i − 1 ] [ k ] [ p r e ( a i , k ) ] + l e n − k − t e m p ) + t e m p
如此每次从 dp[i−1] d p [ i − 1 ] 转移到 dp[i] d p [ i ] 都会加上 temp t e m p 这一定值，若在转移中不考虑该定值，而是累加该值在转移结束后直接加到答案中，那么就不用进行第一种转移，此时复杂度为 O(n⋅len) O ( n ⋅ l e n )
Code
#include1);
}
int deal(int S,int T)
{
for(int i=len;i;i--)
if(suf(S,i)==pre(T,i))return i;
return 0;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",s);
len=strlen(s);
for(int j=0;j2*a[i]+s[j]-'0';
}
int res=0;
memset(dp,INF,sizeof(dp));
dp[0][0]=len;
for(int i=2;i<=n;i++)
{
int l=len-deal(a[i-1],a[i]);
res+=l;
int mn=INF;
for(int j=0;j<=len;j++)mn=min(mn,dp[j][pre(a[i],j)]+len-j-l);
//另一个序列的末尾接上a[i],a[i-1]变成另一个序列末尾
for(int j=0;j<=len;j++)dp[j][suf(a[i-1],j)]=min(dp[j][suf(a[i-1],j)],mn);
}
printf("%d\n",dp[0][0]+res);
return 0;
}