poj1080 dp

题意：已知两段基因序列，求这两段基因序列的最大相似度。由于基于只由ACGT组成，而且缺省的基因可以用字符“-”来代替，已知任意两个基因的相似度表（包括-），求两段             基因的最大相似度。由于两段基因可能丢失了个别基因，使得长度不等，可以通过补充字符"-"，但是进行比较时，两段基因不能在同一个位置都为“-”。

基因序列相似度表

样例：

7 AGTGATG 
5 GTTAG 

这两段基因的通过添加“-”字符达到的最大相似度为

AGTGATG 
 - GTTA -G 

 (-3)+5+5+(-2)+5+(-1) +5=14

题解：

一、拿到这个题目，虽然知道是需要用动态规划解决，但是自己就是不知道如何设置状态和状态转移方程。自己唯一想到的解法就是dfs，在求遍历每个位置的时候，我们有三种比较状态，假设序列1遍历到第i个字符，序列2遍历到第j个字符，即

1. 第一个序列使用第i个字符，第二个序列使用第j个字符
2. 第一个序列使用第i个字符，第二个序列补充字符“-”
3. 第一个序列补充字符“-”，第二个序列使用第j个字符

当变量到第一个序列的第i个字符，第二个序列的第j个字符时，都得枚举上面的三种情况，直到两个序列都到达末尾。

由于每个位置都有3种扩展方法，假设序列1长度为n1，序列2长度为n2，时间复杂度为O(3^(n1+n2))（貌似错了，大牛指点），这种暴搜的方法肯定会超时的。

代码如下：

#include <stdio.h>
#include <string.h>


#define MAXLEN 101

enum gene{A, C, G, T};

int score_matrix[5][5] = 
{
	{5, -1, -2, -1, -3},
	{-1, 5, -3, -2, -4},
	{-2, -3, 5, -2, -2},
	{-1, -2, -2, 5, -1},
	{-3, -4, -2, -1, 0}
};

int max_score;

int convertCharToInteger(char c)
{
	switch (c)
	{
	case 'A':
		return 0; break;
	case 'C':
		return 1; break;
	case 'G':
		return 2; break;
	case 'T':
		return 3; break;
	default:
		return 4;
	}
}

void dfs(char *str1, char *str2, int len1, int len2, int i, int j, int sum)
{
	if (i == len1 && j == len2)
	{
		//printf("%d\n", sum);
		if (max_score < sum)
			max_score = sum;
		return ;
	}

	//enum gene gene1 = str1[i];
	//enum gene gene2 = str2[j];
	int gene1 = convertCharToInteger(str1[i]);
	int gene2 = convertCharToInteger(str2[j]);

	if (j < len2)
	{
		sum += score_matrix[4][gene2];
		dfs(str1, str2, len1, len2, i, j+1, sum);
		sum -= score_matrix[4][gene2];
	}
	if (i < len1)
	{
		sum += score_matrix[gene1][4];
		dfs(str1, str2, len1, len2, i+1, j, sum);
		sum -= score_matrix[gene1][4];
	}
	if (i < len1 && j < len2)
	{
		sum += score_matrix[gene1][gene2];
		dfs(str1, str2, len1, len2, i+1, j+1, sum);
		sum -= score_matrix[gene1][gene2];
	}
}

int main(void)
{
	int i;
	int t;
	scanf("%d", &t);
	while (t--)
	{
		char str1[MAXLEN];
		char str2[MAXLEN];
		int len1;
		int len2;
		scanf("%d %s", &len1, str1);
		scanf("%d %s", &len2, str2);

		max_score = -1000;

		dfs(str1, str2, len1, len2, 0, 0, 0);
		printf("%d\n", max_score);
	}

	return 0;
}

二、其实这题的题目原型跟LCS（最长公共子序列）很像，都是给定两个字符串序列，然后让你通过一定的组合（在某些地方添加“-”）来得到一个最大值，LCS是为了得到一个最长的串，本题是为了得到一个最大的相似度。

这里先表示一下两个子串

sequence1：X(x1 x2 x3 .... xM)

sequence2：Y(y1 y2 y3 .... yN)

回想一下LCS的dp解法

dp[m][n]表示序列1的前m个字符和序列2的前n个字符的能够达到的最大的公共子序列的长度

                      dp[m-1][n-1] + 1                                              xm-1 == yn-1

dp[m][n] = 

                      max( dp[m][n-1], dp[m-1][n] )                       xm-1 =/= yn-1

本题也可设置和LCS同样的dp状态

用dp[m][n]表示序列1的前m个字符和序列2的前n个字符进行匹配可以达到的最大相似度

有了上面的dp状态，写出转移方程也就容易多了，无非就是将解法1的暴搜3中状态转化为dp形式

①如果xm==yn

很简单，dp[m][n] = dp[m-1][n-1] + score(xm,yn);

②如果xm=/=yn

为了得到dp[m][n],我们可以通过3种状态进行转化过来

1、xm和yn直接进行匹配dp[m-1][n-1] + score(xm,yn)

2、xm和“-”匹配   dp[m-1][n] + score(xm, -)

3、“-”和yn匹配    dp[m][n-1] + score(-, yn)

然后取上述三种情况的最大值即可

discuss里有人证明，证明过程和LCS相似

代码

#include <stdio.h>
#include <string.h>

#define MAXLEN 101

int score_matrix[5][5] = 
{
	{5, -1, -2, -1, -3},
	{-1, 5, -3, -2, -4},
	{-2, -3, 5, -2, -2},
	{-1, -2, -2, 5, -1},
	{-3, -4, -2, -1, 0}
};

int dp[MAXLEN][MAXLEN];

int max_score;

int convertCharToInteger(char c)
{
	switch (c)
	{
	case 'A':
		return 0; break;
	case 'C':
		return 1; break;
	case 'G':
		return 2; break;
	case 'T':
		return 3; break;
	default:
		return 4;
	}
}

int sovle(char *str1, int len1, char *str2, int len2)
{
	int i;
	int j;
	dp[0][0] = 0;
	for (i = 1; i <= len1; i++)
		dp[i][0] = dp[i-1][0] + score_matrix[convertCharToInteger(str1[i-1])][4];
	for (j = 1; j <= len2; j++)
		dp[0][j] = dp[0][j-1] + score_matrix[4][convertCharToInteger(str2[j-1])];

	for (i = 1; i <= len1; i++)
	{
		for (j = 1; j <= len2; j++)
		{
			int index1 = convertCharToInteger(str1[i-1]);
			int index2 = convertCharToInteger(str2[j-1]);
			if (index1 == index2)
				dp[i][j] = dp[i-1][j-1] + score_matrix[index1][index2];
			else
			{
				int value1 = dp[i-1][j] + score_matrix[index1][4];
				int value2 = dp[i][j-1] + score_matrix[4][index2];
				int value3 = dp[i-1][j-1] + score_matrix[index1][index2];
				dp[i][j] = value1 > value2 ? value1 : value2;
				dp[i][j] = value3 > dp[i][j] ? value3 : dp[i][j];
			}
		}
	}
	return dp[len1][len2];
}

int main(void)
{
	int i;
	int t;
	scanf("%d", &t);
	while (t--)
	{
		char str1[MAXLEN];
		char str2[MAXLEN];
		int len1;
		int len2;
		scanf("%d %s", &len1, str1);
		scanf("%d %s", &len2, str2);

		printf("%d\n", sovle(str1, len1, str2, len2));
	}

	return 0;
}