java – 全局序列对齐动态编程在矩阵中找到最小值

我有2个序列,AACAGTTACC和TAAGGTCA,我正在尝试找到全局序列比对.我设法创建了一个2D数组并创建了矩阵,我甚至用半动态方法填充它.

这是填充矩阵的代码：

void process() {
    for (int i = 1; i <= sequenceA.length; i++) {
        for (int j = 1; j <= sequenceB.length; j++) {
            int scoreDiag = opt[i-1][j-1] + equal(i, j);
            int scoreLeft = opt[i][j-1] - 1;
            int scoreUp = opt[i-1][j] - 1;
            opt[i][j] = Math.max(Math.max(scoreDiag, scoreLeft), scoreUp);
        }
    }
}

private int equal(int i, int j) {
    if (sequenceA[i - 1] == sequenceB[j - 1]) {
        return 1;
    } else {
        return -1;
    }
}

我的主要问题是此代码生成此输出：

 0   -1   -2   -3   -4   -5   -6   -7   -8     
-1   -1    0   -1   -2   -3   -4   -5   -6      
-2   -2    0    1    0   -1   -2   -3   -4     
 -3   -3   -1    0    0   -1   -2   -1   -2      
 -4   -4   -2    0   -1   -1   -2   -2    0      
 -5   -5   -3   -1    1    0   -1   -2   -1       
-6   -4   -4   -2    0    0    1    0   -1      
-7   -5   -5   -3   -1   -1    1    0   -1       
-8   -6   -4   -4   -2   -2    0    0    1      
 -9   -7   -5   -5   -3   -3   -1    1    0      
-10   -8   -6   -6   -4   -4   -2    0    0 

但我希望它看起来像这样(我只关心图片中的数字)：

我必须应用惩罚：每个不匹配1和每个差距2,如果它匹配0.

解决方法:

您需要修改以下几项内容：

>请注意,在图像中,您可以从右下角到左上角对齐.因此,在该图像中,他们并没有真正调整AACAGTTACC和TAAGGTCA,而是CCATTGACAA和ACTGGAAT.
>你说你想要一个global alignment,但你实际上计算的是local alignment.主要区别在于序列开头的惩罚.在全局对齐中,您必须在第一行和第一列计算插入和删除.
>第三,你没有正确地应用你提到的处罚.相反,你总是用-1惩罚并用1奖励.
>在示例图像中,它们没有在每个位置获取最大值,而是最小值(这是因为您的惩罚是正数而奖励是0,而不是相反,因此您希望最小化值).

完整的解决方案是：

// Note that these sequences are reversed!
String sequenceA ="CCATTGACAA";
String sequenceB = "ACTGGAAT";

// The penalties to apply
int gap = 2, substitution = 1, match = 0;

int[][] opt = new int[sequenceA.length() + 1][sequenceB.length() + 1];

// First of all, compute insertions and deletions at 1st row/column
for (int i = 1; i <= sequenceA.length(); i++)
    opt[i][0] = opt[i - 1][0] + gap;
for (int j = 1; j <= sequenceB.length(); j++)
    opt[0][j] = opt[0][j - 1] + gap;

for (int i = 1; i <= sequenceA.length(); i++) {
    for (int j = 1; j <= sequenceB.length(); j++) {
        int scoreDiag = opt[i - 1][j - 1] +
                (sequenceA.charAt(i-1) == sequenceB.charAt(j-1) ?
                    match : // same symbol
                    substitution); // different symbol
        int scoreLeft = opt[i][j - 1] + gap; // insertion
        int scoreUp = opt[i - 1][j] + gap; // deletion
        // we take the minimum
        opt[i][j] = Math.min(Math.min(scoreDiag, scoreLeft), scoreUp);
    }
}

for (int i = 0; i <= sequenceA.length(); i++) {
    for (int j = 0; j <= sequenceB.length(); j++)
        System.out.print(opt[i][j] + "\t");
    System.out.println();
}

结果就像你给我们的例子一样(但是反过来,记住！)：

0   2   4   6   8   10  12  14  16  
2   1   2   4   6   8   10  12  14  
4   3   1   3   5   7   9   11  13  
6   4   3   2   4   6   7   9   11  
8   6   5   3   3   5   7   8   9   
10  8   7   5   4   4   6   8   8   
12  10  9   7   5   4   5   7   9   
14  12  11  9   7   6   4   5   7   
16  14  12  11  9   8   6   5   6   
18  16  14  13  11  10  8   6   6   
20  18  16  15  13  12  10  8   7

因此,在opt [sequenceA.length()] [sequenceB.length()](7)中找到最终的比对分数.如果您确实需要在图像中显示反转矩阵,请执行以下操作：

for (int i = sequenceA.length(); i >=0; i--) {
    for (int j = sequenceB.length(); j >= 0 ; j--)
        System.out.print(opt[i][j] + "\t");
    System.out.println();
}

标签：java,arrays,matrix,dynamic-programming,sequence-alignment
来源： https://codeday.me/bug/20190703/1366662.html