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;
}