poj 1080 Human Gene Functions(lcs,较难)

Human Gene Functions

Time Limit: 1000MS   Memory Limit: 10000K
Total Submissions: 19573   Accepted: 10919

Description

It is well known that a human gene can be considered as a sequence, consisting of four nucleotides, which are simply denoted by four letters, A, C, G, and T. Biologists have been interested in identifying human genes and determining their functions, because these can be used to diagnose human diseases and to design new drugs for them.

A human gene can be identified through a series of time-consuming biological experiments, often with the help of computer programs. Once a sequence of a gene is obtained, the next job is to determine its function. 
One of the methods for biologists to use in determining the function of a new gene sequence that they have just identified is to search a database with the new gene as a query. The database to be searched stores many gene sequences and their functions – many researchers have been submitting their genes and functions to the database and the database is freely accessible through the Internet.

A database search will return a list of gene sequences from the database that are similar to the query gene. 
Biologists assume that sequence similarity often implies functional similarity. So, the function of the new gene might be one of the functions that the genes from the list have. To exactly determine which one is the right one another series of biological experiments will be needed.

Your job is to make a program that compares two genes and determines their similarity as explained below. Your program may be used as a part of the database search if you can provide an efficient one. 
Given two genes AGTGATG and GTTAG, how similar are they? One of the methods to measure the similarity 
of two genes is called alignment. In an alignment, spaces are inserted, if necessary, in appropriate positions of 
the genes to make them equally long and score the resulting genes according to a scoring matrix.

For example, one space is inserted into AGTGATG to result in AGTGAT-G, and three spaces are inserted into GTTAG to result in –GT--TAG. A space is denoted by a minus sign (-). The two genes are now of equal 
length. These two strings are aligned:

AGTGAT-G 
-GT--TAG

In this alignment, there are four matches, namely, G in the second position, T in the third, T in the sixth, and G in the eighth. Each pair of aligned characters is assigned a score according to the following scoring matrix. 

denotes that a space-space match is not allowed. The score of the alignment above is (-3)+5+5+(-2)+(-3)+5+(-3)+5=9.

Of course, many other alignments are possible. One is shown below (a different number of spaces are inserted into different positions):

AGTGATG 
-GTTA-G

This alignment gives a score of (-3)+5+5+(-2)+5+(-1) +5=14. So, this one is better than the previous one. As a matter of fact, this one is optimal since no other alignment can have a higher score. So, it is said that the 
similarity of the two genes is 14.

Input

The input consists of T test cases. The number of test cases ) (T is given in the first line of the input file. Each test case consists of two lines: each line contains an integer, the length of a gene, followed by a gene sequence. The length of each gene sequence is at least one and does not exceed 100.

Output

The output should print the similarity of each test case, one per line.

Sample Input

2
7 AGTGATG
5 GTTAG
7 AGCTATT
9 AGCTTTAAA 

Sample Output

14
21 

题目大意是就是求两基因的相似度,先要在每个基因对中加入若干空格,然后再依次加上匹配度,详见上表,则相似度就是最大的匹配度和

例如对于测试数据一,加上空格则变成

AGTGAT--G

-GT----TAG

则相似度就是(-3)+5+5+(-2)+5+(-1)+5=14,可以证明这是最大的,故为所求

此题为dp,详见代码

 1 #include<iostream>
 2 #include<cstdlib>
 3 #include<cstdio>
 4 #include<cstring>
 5 #include<algorithm>
 6 #include<cmath>
 7 using namespace std;
 8 int map[][5]={    {5,-1,-2,-1,-3},
 9                 {-1,5,-3,-2,-4},
10                 {-2,-3,5,-2,-2},
11                 {-1,-2,-2,5,-1},
12                 {-3,-4,-2,-1,0} };
13 char str1[105];
14 char str2[105];
15 int f[256];
16 bool vis[105][105];
17 int ans[105][105];
18 int DFS ( int x , int y )
19 {
20
21     int i ;
22     int xy=0;
23     if ( x == -1 )
24     {
25         for ( i = 0 ; i <= y ; i ++ )
26             xy += map[str2[i]][4] ;
27         return xy ;
28     }
29     if ( y == -1 )
30     {
31         for ( i = 0 ; i <= x ; i ++ )
32             xy += map[str1[i]][4] ;
33         return xy ;
34     }
35     if ( vis[x][y] )
36         return ans[x][y] ;
37     vis[x][y]=true;
38     ans[x][y] = max ( DFS ( x - 1 , y - 1 ) + map[str1[x]][str2[y]] , max ( DFS(x,y-1)+map[4][str2[y]] , DFS(x-1,y)+map[str1[x]][4] )) ;
39     return ans[x][y] ;
40 }
41 int main()
42 {
43     f[‘A‘]=0;
44     f[‘C‘]=1;
45     f[‘-‘]=4;
46     f[‘G‘]=2;
47     f[‘T‘]=3;
48     int t ;
49     cin >> t ;
50     while ( t -- )
51     {
52         int i , j ;
53         int len1 , len2 ;
54         cin >> len1 >> str1 ;
55         for ( i = 0 ; i < len1 ; i ++ )
56             str1[i]=f[str1[i]];
57
58         cin >> len2 >> str2 ;
59         for ( i = 0 ; i < len2 ; i ++ )
60             str2[i]=f[str2[i]];
61         memset ( vis , 0 , sizeof ( vis ) ) ;
62         cout << DFS(len1-1,len2-1) << endl ;
63     }
64     return 0;
65 }

 1 #include<cstdio>
 2 #include<cstdlib>
 3 #include<iostream>
 4 #include<algorithm>
 5
 6 using namespace std;
 7 /*dp,poj1080*/
 8
 9 int dp[105][105];//动态规划数据存放
10  int map[105][105];//用来存放原始数据
11
12  void map_init()
13  {
14      map[‘A‘][‘A‘]=map[‘C‘][‘C‘]=map[‘G‘][‘G‘]=map[‘T‘][‘T‘]=5;
15      map[‘A‘][‘C‘]=map[‘C‘][‘A‘]=map[‘A‘][‘T‘]=map[‘T‘][‘A‘]=map[‘T‘][‘ ‘]=map[‘ ‘][‘T‘]=-1;
16      map[‘A‘][‘G‘]=map[‘G‘][‘A‘]=map[‘C‘][‘T‘]=map[‘T‘][‘C‘]=map[‘G‘][‘T‘]=map[‘T‘][‘G‘]=map[‘G‘][‘ ‘]=map[‘ ‘][‘G‘]=-2;
17      map[‘A‘][‘ ‘]=map[‘ ‘][‘A‘]=map[‘G‘][‘C‘]=map[‘C‘][‘G‘]=-3;
18      map[‘C‘][‘ ‘]=map[‘ ‘][‘C‘]=-4;
19  }
20
21  int max_X3(int a,int b,int c)
22  {
23      if(a>b)
24      {
25          if(a>c)
26              return a;
27          else
28              return c;
29      }
30      else
31      {
32          if(b>c)
33              return b;
34          else
35              return c;
36      }
37  }
38
39  int    main()
40  {
41      int y;//全局次数
42      int i,j;//循环变量
43      int a,b;//用户输入
44      char str1[105];
45      char str2[105];
46
47      //初始化
48      map_init();
49
50      cin>>y;
51      while (y--)
52      {
53          scanf("%d %s",&a,str1);
54          scanf("%d %s",&b,str2);
55
56          //初始化第一行第一列
57          dp[0][0]=0;
58          for (i = 0; i < a; i++)
59              dp[0][i+1] = dp[0][i] + map[str1[i]][‘ ‘];
60
61          for (j = 0; j < b; j++)
62              dp[j+1][0] = dp[j][0] + map[str2[j]][‘ ‘];
63
64          for (i = 1; i <= a; i++)
65          {
66              for (j = 1; j <= b; j++)
67              {
68                  dp[j][i] = max_X3(dp[j-1][i-1]+map[str2[j-1]][str1[i-1]],
69                      dp[j-1][i]+map[str2[j-1]][‘ ‘],
70                      dp[j][i-1]+map[str1[i-1]][‘ ‘]);
71              }
72          }
73
74          cout<<dp[b][a]<<endl;
75      }
76      return 0;
77  }

时间: 2024-10-26 00:28:16

poj 1080 Human Gene Functions(lcs,较难)的相关文章

POJ - 1080 - Human Gene Functions (LCS的变形)

题目传送:Human Gene Functions 思路:LCS的变形,定义状态dp[ i ][ j ]为取字符串s前i个字符字符串t前j个字符所获得的最大值,则可以得到状态转移方程为: dp[ i ][ j ] = max(dp[ i ][ j - 1] + f[ ' - ' ][ t[ j ] ], dp[ i - 1 ][ j ] + f[ s [ i ] ][ ' - ' ], dp[i - 1][ j - 1] + f[ s [ i ] ][ t [ j ] ]); AC代码: #in

POJ 1080 Human Gene Functions(LCS)

Description It is well known that a human gene can be considered as a sequence, consisting of four nucleotides, which are simply denoted by four letters, A, C, G, and T. Biologists have been interested in identifying human genes and determining their

POJ 1080 Human Gene Functions(求两字符串相似度:LCS变形)

POJ 1080 Human Gene Functions(求两字符串相似度:LCS变形) http://poj.org/problem?id=1080 题意: HDU1080 给你两个由字符A,C,G,T构造的字符串s1和s2, 现在你可以在这两个字符串中插入空格, 使得两串长相等(但是不能使得s1的空格对应s2的空格位置). 然后给你s1的特定字符对应s2中特定字符所能获得的分数矩阵: 问你最后两个字符串所能获得的最大分数是多少? 分析: 本题很类似于求字符串最短编辑距离或者求字符串LCS的

POJ #1080 - Human Gene Functions

A classic 2D DP problem. A disguise of LCS - actually not very hard to decode: it is about 2 sequences' matching, though with a weight value of each match. The point of this problem: how to decode problem statement and how to distill the actuall mode

POJ 1080 Human Gene Functions(动态规划)

一开始用的DFS,无限TLE,贴丑代码 //version 1 TLE #include<cstdio> #include<cstring> #include<iostream> #define MAX_INT 2147483647 #define MAXN 105 using namespace std; int Map[5][5] = { {0,-3,-4,-2,-1}, {-3,5,-1,-2,-1}, {-4,-1,5,-3,-2}, {-2,-2,-3,5,-

POJ 1080 Human Gene Functions(DP)

Human Gene Functions Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 18007   Accepted: 10012 Description It is well known that a human gene can be considered as a sequence, consisting of four nucleotides, which are simply denoted by four

poj 1080 ——Human Gene Functions——————【最长公共子序列变型题】

Human Gene Functions Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 17805   Accepted: 9917 Description It is well known that a human gene can be considered as a sequence, consisting of four nucleotides, which are simply denoted by four

poj 1080 Human Gene Functions (dp,LCS)

链接:poj 1080 题意:给定两个字符串,求它们对齐匹配的最大值 要求:可以两个字符匹配,也可以一个字符和'-'匹配, 但是不能两个'-'匹配,例如: AGTGATG GTTAG 这两个字符串可以看成是 AGTGATG -GTTA-G 也可以看成是 AGTGAT-G -GT--TAG 分析:这是一个变形的最长公共子序列,最优解: 1.取字符i-1和j-1的时候dp[i][j]=dp[i-1][j-1]+a[s1[i-1]][s2[j-1]]; 2.取字符i-1,不取j-1的时候dp[i][j

POJ 1080 Human Gene Functions 【dp】

题目大意:每次给出两个碱基序列(包含ATGC的两个字符串),其中每一个碱基与另一串中碱基如果配对或者与空串对应会有一个分数(可能为负),找出一种方式使得两个序列配对的分数最大 思路:字符串动态规划的经典题,很容易想到状态dp[i][j],指第一个长度为i的串和第二个长度为j的串配对的最大分数.显然,这个状态可以由dp[i][j-1],dp[i-1][j],dp[i-1][j-1]三个子问题得到,即第一串最后一个字符对应空格.第二串最后一个字符对应空格和第一串第二串最后一个字符配对所得到的分数这三