poj 1080 Human Gene Functions

/*
*  poj 1080 人类基因组

题目大意:
人类的基因共有4种核苷酸组成，分别可以用字符A/C/T/G代表。根据给定的相似度
计算规则，给出两个基因片段的最大相似度。计算规则如下:

可以向序列中插入空格，使得两个基因串得到相同的长度。两串相同位置上的字母
进行比较，按照如下表格记录每个字符的得分，累加各个位置得分即为该种填充法
得到的相似度。

A   C   G   T   -

A    5  -1  -2  -1  -3

C   -1   5  -3  -2  -4

G   -2  -3   5  -2  -2

T   -1  -2  -2   5  -1

-   -3  -4  -2  -1   *

数学模型:

f(i, j)表示a[1..i]子串与b[1..j]子串能够取得的最大相似度，则有如下递归公式成立:

f(i, j) = max(f(i-1, j)+s(a[i], ' '), f(i, j-1)+s(b[j], ' '), f(i-1, j-1)+s(a[i], b[j]))

a[1]    ......      a[i-1]   a[i]
\    / |
\  /  |
\/   |
/\   |
/  \  |
/    \ |
/      \|
b[1]    ......     b[j-1]    b[j]

如上图所示，

f(i-1, j)+s(a[i], ' ')表示a[i]与b[j]后面添加的空格相匹配，而a[1..i-1]子串与b[1..j]子串尝试取得最大相似度的情况
-- 如果此时取得最大相似度则必然有a[1..i-1]子串与b[1..j]子串尝试取得了最大相似度，此为最优子问题的结构!!

f(i, j-1)+s(b[j], ' ')表示b[j]与a[i]后面添加的空格相匹配，而a[1..i]子串与b[1..j-1]子串尝试取得最大相似度的情况
-- 如果此时取得最大相似度则必然有a[1..i]子串与b[1..j-1]子串尝试取得了最大相似度，此为最优子问题的结构!!

f(i-1, j-1)+s(a[i], b[j])表示a[i]与b[j]相匹配，而a[1..i-1]子串与b[1..j-1]子串尝试取得最大相似度的情况
-- 如果此时取得最大相似度则必然有a[1..i-1]子串与b[1..j-1]子串尝试取得了最大相似度，此为最优子问题的结构!!

重叠子问题通过上面分析已经显而易见了。 -- 本题是LCS的变形

*/

#include <iostream>
#include <cstdio>

namespace {
using namespace std;

const int NEG_INFINITY = -500; // 负无穷
int l1, l2, f[101][101]; // 两串长度解空间存储

char gs1[101], gs2[102]; // 基因串编码

// 差异算分表
int score_matrix[][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,  NEG_INFINITY}
};

int max_human_gene()
{
// 初始化，f[0][0]必须初始化为0
f[0][0] = 0;

// 初始化，f[i][0]表示a[1..i]子串与b空串的最大得分
int sum = 0;
for (int i=1; i<=l1; i++)
{
sum += score_matrix[gs1[i]][4];
f[i][0] = sum;
}

// 初始化，f[0][j]表示b[1..j]子串与a空串的最大得分
sum = 0;
for (int j=1; j<=l2; j++)
{
sum += score_matrix[4][gs2[j]];
f[0][j] = sum;
}

// 自底向上求解f[i][j]，其实可以用滚动数组的，代码会相对繁琐些
for (int i=1; i<=l1; i++)
{
for (int j=1; j<=l2; j++)
{
f[i][j] = NEG_INFINITY;

if (f[i-1][j]+score_matrix[gs1[i]][4] > f[i][j])
f[i][j] = f[i-1][j]+score_matrix[gs1[i]][4];

if (f[i][j-1]+score_matrix[4][gs2[j]] > f[i][j])
f[i][j] = f[i][j-1]+score_matrix[4][gs2[j]];

if (f[i-1][j-1]+score_matrix[gs1[i]][gs2[j]] > f[i][j])
f[i][j] = f[i-1][j-1]+score_matrix[gs1[i]][gs2[j]];
}
}

return f[l1][l2];
}
}

// 将基因字符数字编码化，用于快速查表
#define transform(x) \
do \
{\
switch ((x)) \
{ \
case 'A': case 'a': \
x = 0; \
break; \
case 'C': case 'c': \
x = 1; \
break; \
case 'G': case 'g': \
x = 2; \
break; \
case 'T': case 't': \
x = 3; \
break; \
} \
} while (0)

int main()
{
int T;
scanf("%d", &T);
for (int t=0; t<T; t++)
{
scanf("%d", &l1);
scanf("%s", &gs1[1]);
for (int i=1; i<=l1; i++)
{
transform(gs1[i]);
}

scanf("%d", &l2);
scanf("%s", &gs2[1]);
for (int i=1; i<=l2; i++)
{
transform(gs2[i]);
}

printf("%d\n", max_human_gene());
}

return 0;
}