POJ 1795 DNA Laboratory

题意：

给n个由A C T G组成的字符串。

要求用这些字符串拼接，（如果两个穿的前缀和后缀有相同的部分可以重合），要求拼接成的串

长度最短且字典序最小。

 

一直觉得是什么“字符串不会做系列”的难题，结果是一道状压DP+dfs

看到n=15这么灵性的数字应该要灵性一下的。。。

二进制状压一下

dp[state][j] 表示在state状态下，最前面的串是j的情况

然后需要预处理一下两个串拼接的时候增加的长度

dist[i][j] 表示把第i个串拼在第j个串前面增加的长度：也就是i串的长度减去i的后缀和j的前缀重合的长度

对于dfs回溯

在得到短长度，并且字典序在当前最小时，最前面的串j时，需要找第二个串，已经知道dp[all-state[j]][j]

那么枚举转移过来的情况 找到满足dp值满足，并且拼接后字典序最小的（注意这里是要去拼接比较一下，因为直接比较可能把前缀就隐藏了，不是直接比较下一个串的字典序）

易错，还有一点在输入串后，要办能够直接有完全重合的串处理掉。

 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <stack>
#include <set>
#include <map>
#include <math.h>
#define pb push_back
#define CLR(a) memset(a, 0, sizeof(a));
#define MEM(a, b) memset(a, b, sizeof(a));
#define fi first
#define se second

using namespace std;

typedef long long ll;

const int MAXN = 107;
const int MAXV = 207;
const int MAXE = 207;
const int INF = 0x3f3f3f3f;

int sz;
char s[MAXN << 1][MAXN];
char str[MAXN << 1][MAXN];
int n;
int state[27];
int dp[67000 << 1][27];
int dist[27][27];
char anstr[MAXN*MAXN << 1];
void deal()
{
    for (int i = 0; i < sz; i++)
    {
        for (int j = 0; j < sz; j++)
        {
            if (i == j) continue;
            int len = min(strlen(s[i]), strlen(s[j]));
            for (int l = len; l >= 0; l--)
            {
                char ss[MAXN];
                strcpy(ss, s[j]);
                ss[l] = '\0';
                //if (i == 0 && j == 1) cout << l << " : " << s[i]+(strlen(s[i])-l) << " " << ss << endl;
                if (strcmp(s[i]+(strlen(s[i])-l), ss) == 0) 
                {
                    dist[i][j] = strlen(s[i]) - l;
                    break;
                }
            }
        }
    }
}

int all;
void dfs(int crt, int pre)
{
    if (crt == 0) return;
    int tmp = INF;
    int now = -1;
    char ts1[MAXN*MAXN], ts2[MAXN*MAXN];
    bool have = false;
    strcpy(ts1, anstr);
    for (int i = 0; i < sz; i++)
    {
        if (crt & state[i])
        {
            if (dp[crt+state[pre]][pre] == dp[crt][i] + dist[pre][i]) 
            {
                if (!have)
                {
                    now = i;
                    have = 1;
                    int d = strlen(s[pre]) -  dist[pre][now];
                    strcat(ts1, s[now]+d);
                }
                else 
                {
                    strcpy(ts2, anstr);
                    int d = strlen(s[pre]) -  dist[pre][i];
                    strcat(ts2, s[i]+d);
                    if (strcmp(ts2, ts1) < 0)
                    {
                        now = i;
                        strcpy(ts1, ts2); 
                    }
                }
            }
        }
    }
    strcpy(anstr, ts1);
    dfs(crt - state[now], now);
}
int main()
{
    state[0] = 1;
    for (int i = 1; i <= 16; i++) state[i] = state[i-1] << 1;
    int T;
    scanf("%d", &T);
    for (int cas = 1; cas <= T; cas++)
    {
        sz = 0;
        scanf("%d", &n);
        for (int i = 0; i < n; i++) scanf("%s", str[i]);
        for (int i = 0; i < n; i++)
        {    
            bool flag = true;
            for (int j = 0; j < n; j++)
            {
                if (i == j) continue;
                if (strstr(str[j], str[i]))
                {
                    flag = false;
                    break;
                }
            }
            if (flag) strcpy(s[sz++], str[i]);
        }
        printf("Scenario #%d:\n", cas);
        if (sz == 0)
        {
            cout << str[0] << endl << endl;
            continue;
        }
        if (sz == 1) 
        {
            cout << s[0] << endl << endl;
            continue;
        }
        deal();
        all = state[sz] - 1;
        MEM(dp, 0x3f);
        for (int i = 0; i < sz; i++) dp[state[i]][i] = strlen(s[i]);
        for (int i = 0; i <= all; i++)
        {
            for (int j = 0; j < sz; j++)
            {
                if (dp[i][j] == INF) continue;
                for (int k = 0; k < sz; k++)
                {
                    if (state[k] & i) continue;
                    dp[i+state[k]][k] = min(dp[i+state[k]][k], dp[i][j]+dist[k][j]);
                }
            }
        }
        int ans = INF;
        int now = -1;
        for (int i = 0; i < sz; i++)
        {
            if (ans > dp[all][i]) 
            {
                ans = dp[all][i];
                strcpy(anstr, s[i]);
                now = i;
            }
            else if (ans == dp[all][i] && strcmp(s[i], anstr) < 0) 
            {
                strcpy(anstr, s[i]);
                now = i;
            }
        }
        dfs(all-state[now], now);
        cout << anstr << endl << endl;
    }
    return 0;
}