【POJ1795】DNA Laboratory（状态压缩DP）

题目大意

给定n$(1≤n≤15)$个字符串，只会由'A' 'C' 'G' 'T' 四种字符构成，求一个最短的字符串S，使得给定的n个字符串均为S的字串，如果有多解，输出字典序最小的S。

题解

题意说白了就是，把给定的字符串拿来拼凑，相邻的字符串去掉重复部分，拼一个最短，字典序最小的字符串。TGCACA和CAT去掉重复的CA就得到了TGCACAT。
首先我们可以把那些被包含在其它字符串的子串全部去掉，然和用剩下的来拼凑。

数据规模很小，考虑状态压缩DP。
用状态ｓ表示当前已经选择了哪些字符串来拼凑。因为转移状态时，添加一个新的字符串来拼凑，我们需要知道当前拼凑结果中，最前面的字符，这样才能计算新添加的字符串与当前已拼凑有多少重合。用i来表示最前面的是哪个字符串。
dp[s][i]表示选择状态为s，最前面为第i个的字符串能拼凑出的最短字符串长度。
为了最后构造出这个最短字符串，我们还需要一个数组：
second[s][i]表示选择状态为s，最前面为第i个字符串拼凑出最短字符串时，前面第二个字符串为哪一个。

状态转移方程：（刷表法，从dp[s][i]转移到后面）
dp[new][j]=min(dp[new][j],dp[s][i]+length[j]-rep[j][i]);
（length[j]表示字符串j的长度）
（rep[j][i]表示j在前，i在后时，它们能重复的长度，如TGCACA与CAT的rep值为2，这个数组可以预处理出来）

初始时dp[(1<<(i-1)][i]=length[i]（只选一个字符串），其余全部无限大。
转移时，要判断字符串大小，以达到second数组一定是按字典序最小的方案存储的。
最后dp[(1<<n)-1][1~n]为目标状态，枚举出最小值，利用second倒推回去，构造出字符串S。

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN=17,MAXL=105,MAXS=1<<15;
int N;
string DNA[MAXN];
int dp[MAXS][MAXN],second[MAXS][MAXN];
int rep[MAXN][MAXN],length[MAXN];
bool cmp(int i,int x,int j,int y)
{
    for(int p=x,q=y;p<length[i]&&q<length[j];p++,q++)
        if(DNA[i][p]>DNA[j][q])
            return 1;
        else if(DNA[i][p]<DNA[j][q])
            return 0;
    return 0;
}
int main()
{
    int T,maxs,n;
    scanf("%d",&T);
    for(int Case=1;Case<=T;Case++)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            cin>>DNA[i];
        N=n;
        //删除被包含的字符串，在它们前面添上'z'，排序后就跑到后面去了
        for(int i=1;i<=n;i++)
        {
            if(DNA[i][0]=='z')
                continue;
            for(int j=1;j<=n;j++)
                if(i!=j&&DNA[j][0]!='z'&&DNA[i].find(DNA[j])!=string::npos)
                {
                    DNA[j]="z"+DNA[j];
                    N--;
                }
        }
        sort(DNA+1,DNA+n+1);
        for(int i=1;i<=n;i++)
            length[i]=DNA[i].length();
        maxs=1<<N;
        //预处理rep数组
        for(int i=1;i<=N;i++)
            for(int j=1;j<=N;j++)
            {
                int l1=length[i],l2=length[j];
                for(int k=min(l1,l2);k>=0;k--)
                {
                    bool success=1;
                    for(int p=0;p<k&&success;p++)
                        if(DNA[i][l1-k+p]!=DNA[j][p])
                            success=0;
                    if(success)
                    {
                        rep[i][j]=k;
                        break;
                    }
                }
            }
        memset(dp,0x7F,sizeof dp);
        for(int i=1;i<=N;i++)
            dp[1<<(i-1)][i]=length[i];
        for(int s=0;s<maxs;s++)
            for(int i=1;i<=N;i++)
                if(dp[s][i]!=0x7F7F7F7F)
                    for(int j=1,bit=1;j<=N;j++,bit<<=1)
                        if(i!=j&&(bit&s)==0)
                        {
                            int res=dp[s][i]+length[j]-rep[j][i],&st=dp[s^bit][j];
                            //cmp比较字符串大小，比较第二个字符串除去被第一个字符串重复掉的部分
                            if(st>res||(st==res&&cmp(second[s^bit][j],rep[j][second[s^bit][j]],i,rep[j][i])))
                            {
                                st=res;
                                second[s^bit][j]=i;
                            }
                        }
        string ans;
        int len=0x7F7F7F7F,cur,last=0,state=maxs-1,temp;
        for(int i=1;i<=N;i++)
            if(len>dp[state][i]||(len==dp[state][i]&&cmp(cur,0,i,0)))
            {
                len=dp[state][i];
                cur=i;
            }
        //倒推构造答案字符串
        while(cur)
        {
            ans+=DNA[cur].substr(last,len-last);
            temp=second[state][cur];
            last=rep[cur][temp];
            state^=1<<(cur-1);
            cur=temp;
        }
        printf("Scenario #%d:\n%s\n\n",Case,ans.c_str());
    }
    return 0;
}