HDOJ 1080 Human Gene Functions(DP)

方程不是很难的 DP，刚开始看错题意，以为是在较短串里加空格使得匹配度最好，后来看了 discuss 才发现长串也可以加空格。。。

dp(i,j) 表示以串1的第 i 位开始的串和以串2的第 j 位开始的串的最大匹配值。

dp(i,j) = max( dp(i+1,j)+f(s1[i], '-'), dp(i,j+1)+f('-', s2[j]), dp(i+1,j+1)+f(s1[i], s2[j])

需要注意一下边界，当 i 或 j 到达其对应串的最后一位时，可以将另一个串的剩下的所有位都与 '-' 对应。

具体细节见代码。

PS:记忆化搜索的代码反而比直接循环的快，至少能证明这题二者相差不是很大

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

const int maxn = 110, inf = 0x3f3f3f3f;

int tab[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 getn(char c)
{
    switch(c) {
        case 'A': return 0;
        case 'C': return 1;
        case 'G': return 2;
        case 'T': return 3;
        case '-': return 4;
        default: return -1;
    }
}

int f(char x, char y) {return tab[getn(x)][getn(y)]; }

int lena, lenb;
char s1[maxn], s2[maxn];
char temp[maxn];

int dpa[maxn][maxn];

int dp(int i, int j)
{
    if(dpa[i][j] > -inf) return dpa[i][j];
    int ret = -inf;
    if(i == lena-1 && j == lenb-1)
        ret = f(s1[i], s2[j]);
    else {
        if(i < lena-1) ret = max(ret, dp(i+1,j)+f(s1[i],'-'));
        if(j < lenb-1) ret = max(ret, dp(i,j+1)+f('-',s2[j]));
        if(i < lena-1 && j < lenb-1) ret = max(ret, dp(i+1,j+1)+f(s1[i],s2[j]));
        if(i == lena-1) {
            int temp = f(s1[i], s2[j]);
            for(int k = 1; k + j < lenb; k++)
                temp += f(s2[j+k], '-');
            ret = max(ret, temp);
        }
        if(j == lenb-1) {
            int temp = f(s1[i], s2[j]);
            for(int k = 1; k + i < lena; k++)
                temp += f(s1[i+k], '-');
            ret = max(ret, temp);
        }
    }

    return dpa[i][j] = ret;
}

int main()
{
    int t;

    scanf("%d", &t);
    while(t--) {
        scanf("%d%s%d%s", &lena, s1, &lenb, s2);
//        if(lena < lenb) {
            swap(s1, s2);
//            strcpy(temp, s1);
//            strcpy(s1, s2);
//            strcpy(s2, temp);
//            swap(lena, lenb);
//        }
        for(int i = 0; i < lena; i++)
            for(int j = 0; j < lenb; j++)
                dpa[i][j] = -inf;
//        for(int i = lena-1; i >= 0; i--) {
//            for(int j = lenb-1; j >= 0; j--) {
//                if(i == lena-1 && j == lenb-1)
//                    dpa[i][j] = f(s1[i], s2[j]);
//                else {
//                    if(i < lena-1) dpa[i][j] = max(dpa[i][j], dpa[i+1][j]+f(s1[i],'-'));
//                    if(j < lenb-1) dpa[i][j] = max(dpa[i][j], dpa[i][j+1]+f('-',s2[j]));
//                    if(i < lena-1 && j < lenb-1) dpa[i][j] = max(dpa[i][j], dpa[i+1][j+1]+f(s1[i],s2[j]));
//                    if(i == lena-1) {
//                        int temp = f(s1[i], s2[j]);
//                        for(int k = 1; k + j < lenb; k++)
//                            temp += f(s2[j+k], '-');
//                        dpa[i][j] = max(dpa[i][j], temp);
//                    }
//                    if(j == lenb-1) {
//                        int temp = f(s1[i], s2[j]);
//                        for(int k = 1; k + i < lena; k++)
//                            temp += f(s1[i+k], '-');
//                        dpa[i][j] = max(dpa[i][j], temp);
//                    }
//                }
//            }
//        }
        printf("%d\n", dp(0,0));
//        printf("%d\n", dpa[0][0]);
    }

    return 0;
}