HDU1560 DNA sequence

题目：

The twenty-first century is a biology-technology developing century. We know that a gene is made of DNA. The nucleotide bases from which DNA is built are A(adenine), C(cytosine), G(guanine), and T(thymine). Finding the longest common subsequence between DNA/Protein sequences is one of the basic problems in modern computational molecular biology. But this problem is a little different. Given several DNA sequences, you are asked to make a shortest sequence from them so that each of the given sequence is the subsequence of it.

For example, given "ACGT","ATGC","CGTT" and "CAGT", you can make a sequence in the following way. It is the shortest but may be not the only one.

输入：

The first line is the test case number t. Then t test cases follow. In each case, the first line is an integer n ( 1<=n<=8 ) represents number of the DNA sequences. The following k lines contain the k sequences, one per line. Assuming that the length of any sequence is between 1 and 5.

输出：

For each test case, print a line containing the length of the shortest sequence that can be made from these sequences.

样例：

分析：公共序列只要满足子序列的排列顺序就行;

IDA*算法，逐渐放大搜索的宽度，并用估价函数（估计仍需匹配的深度）进行剪枝

 #include<iostream>
 #include<sstream>
 #include<cstdio>
 #include<cstdlib>
 #include<string>
 #include<cstring>
 #include<algorithm>
 #include<functional>
 #include<iomanip>
 #include<numeric>
 #include<cmath>
 #include<queue>
 #include<vector>
 #include<set>
 #include<cctype>
 #define PI acos(-1.0)
 const int INF = 0x3f3f3f3f;
 const int NINF = -INF - ;
 typedef long long ll;
 using namespace std;
 int n, deep, ans;//deep记录深度， ans记录答案
 string seq[];//n个子序列
 int siz[];//n个子序列对应的长度
 char DNA[] = {'A', 'C', 'G', 'T'};
 void dfs(int rec, int *pos)//当前匹配到的公共序列的个数， 个子序列匹配到的位置
 {
     if (rec > deep) return;//如果大于搜索深度即加深深度结束
     int hx = ;//估计剩余需匹配的深度
     for (int i = ; i < n; ++i)
     {
         int temp = siz[i] - pos[i];
         hx = max(temp, hx);//剩余需匹配深度为子序列未匹配部分最大长度
     }
     if (!hx)//如果剩余需匹配为0即完成
     {
         ans = rec;
         return;
     }
     if (hx + rec > deep) return;//如果已匹配深度加估计剩余需匹配深度大于限制深度即加深深度结束
     for (int i = ; i < ; ++i)//公共序列下一个值可能的四个
     {
         int tmp[];//类似BFS的操作
         int flag = ;//flag进行了一次剪枝，如果DNA[i]不能匹配当前任何子序列的下一个值则不再进行DFS直接舍弃（从3500ms优化到1200ms）
         for (int j = ; j < n; ++j)
         {
             if (seq[j][pos[j]] == DNA[i])//子序列j的第pos[j]（匹配到位置）若等于
             {
                 flag = ;
                 tmp[j] = pos[j] + ;//匹配成功下次考虑该子序列的下一个位置
             }
             else tmp[j] = pos[j];
         }
         if (flag)
             dfs(rec + , tmp);
         if (ans != -) return;
     }
 }
 int main()
 {
     int T;
     cin >> T;
     while (T--)
     {
         cin >> n;
         int maxn = ;//n个子序列的最大长度
         for (int i = ; i < n; ++i)
         {
             cin >> seq[i];
             siz[i] = seq[i].length();//估价函数需要，记录n个子序列对应长度
             maxn = max(maxn, siz[i]);
         }
         deep = maxn;
         int pos[];//子序列匹配到的位置
         memset(pos, , sizeof(pos));
         ans = -;
         while ()
         {
             dfs(, pos);
             if (ans != -) break;
             deep++;//每进行一次DFS，若未匹配完成则加深搜索深度继续进行
         }
         cout << ans << endl;
     }
     return ;
 }