POJ 1795

DNA Laboratory

Time Limit: 5000MS		Memory Limit: 30000K
Total Submissions: 1425		Accepted: 280

Description

Background
Having started to build his own DNA lab just recently, the evil
doctor Frankenstein is not quite up to date yet. He wants to extract his
DNA, enhance it somewhat and clone himself. He has already figured out
how to extract DNA from some of his blood cells, but unfortunately
reading off the DNA sequence means breaking the DNA into a number of
short pieces and analyzing those first. Frankenstein has not quite
understood how to put the pieces together to recover the original
sequence.

His pragmatic approach to the problem is to sneak into university
and to kidnap a number of smart looking students. Not surprisingly, you
are one of them, so you would better come up with a solution pretty
fast.

Problem

You are given a list of strings over the alphabet A (for adenine), C
(cytosine), G (guanine), and T (thymine),and your task is to find the
shortest string (which is typically not listed) that contains all given
strings as substrings.

If there are several such strings of shortest length, find the smallest in alphabetical/lexicographical order.

Input

The first line contains the number of scenarios.

For each scenario, the first line contains the number n of strings
with 1 <= n <= 15. Then these strings with 1 <= length <=
100 follow, one on each line, and they consist of the letters "A", "C",
"G", and "T" only.

Output

The
output for every scenario begins with a line containing "Scenario #i:",
where i is the number of the scenario starting at 1. Then print a
single line containing the shortest (and smallest) string as described
above. Terminate the output for the scenario with a blank line.

Sample Input

1
2
TGCACA
CAT

Sample Output

Scenario #1:
TGCACAT

Source

TUD Programming Contest 2004, Darmstadt, Germany

好恶心的状态dp啊！！！！

首先对消除能被其他串包含的串，然后对剩下的串进行建边，建一个有向图，长度是位于一个边指向的反方向所对应的串的后缀与边指向的串的相同的最大前缀长度的负数。

设dp[v][s] 是以v为终点，已经访问过集合s所对应的点的最小值，可建立如下方程

dp[v][s] = min(dp[u ][s | （1 << u)] + dis[v][u])       !((1 << u) & s) = = 1

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;

 #define maxn 105

 #define INF 10000

 int n,ca,len,sum;
 char s[][maxn];
 int dp[][( << ) + ],dis[][];
 bool vis[],done[];
 string ans;

 int cal(int x,int y) {
         int  _max = ;
         for(int i = ; i < strlen(s[x]); i++) {
                 if(s[x][i] != s[y][]) continue;
                 int j,k;
                 for( j = i,k = ; j < strlen(s[x]) && k < strlen(s[y]); j++,k++) {
                         if(s[x][j] != s[y][k]) break;
                 }
                 if(k == strlen(s[y])) {
                         done[y] = ;
                         break;
                 }
                 if(j == strlen(s[x])) {
                         _max = max(_max,j - i);

                 }
         }

         return -_max;
 }
 void init() {
     for(int u = ; u < n; u++) {
             if(done[u]) continue;
             for(int v = ; v < n; v++) {
                     if(u == v || done[v]) continue;
                     dis[u][v] = cal(u,v);

             }
     }

 }

 void dfs(int v,int s1) {
         vis[v] = ;
         int id = -;
         string t("z");
         for(int u = ; u < n; u++) {
                 if(done[u] || vis[u]) continue;

                 if(dp[v][s1] == dp[u][s1 | ( << u)] + dis[v][u]) {
                         string t1(s[u] - dis[v][u],s[u] + strlen(s[u]));
                         if(t > t1) {
                                 t = t1;
                                 id = u;
                         }
                 }

         }

         if(id != -) {
                 ans = ans + t;
                 dfs(id,s1 | ( << id));

         }
 }

 void solve() {
     init();

     for(int s1 = ( << n) - ; s1; s1--) {
             for(int v = ; v < n; v++) {
                     if(!(s1 & ( << v)) || done[v]) continue;
                     for(int u = ; u < n; u++) {
                             if(u == v || (s1 & ( << u)) || done[v] ) continue;
                             dp[v][s1] = min(dp[v][s1],dp[u][s1 | ( << u)] + dis[v][u]);

                     }
             }
     }

     int _min = ;
     for(int i = ; i < n; i++) {
             if(done[i]) continue;
             _min = min(_min,dp[i][ << i]);
     }

     memset(vis,,sizeof(vis));

     ans = "z";
     int id;
     for(int i = ; i < n; i++) {
             if(done[i]) continue;
             string t(s[i]);
             if(dp[i][ << i] == _min && ans > t) {
                     ans = t;
                     id = i;
             }
     }

     dfs(id, << id);

     printf("Scenario #%d:\n",ca++);
     cout << ans << endl;

 }
 int main()
 {
     int t;
     //freopen("sw.in","r",stdin);
     scanf("%d",&t);
     ca = ;

     while(t--) {
             memset(done,,sizeof(done));

             scanf("%d",&n);

             for(int i = ; i < n; i++) {
                     scanf("%s",s[i]);
             }

             memset(dis,,sizeof(dis));

             for(int i = ; i < n; i++) {
                     for(int s = ; s < ( << n); s++) {
                             dp[i][s] = ;
                     }
             }

             solve();
             printf("\n");

     }

     return ;
 }