Question

我有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

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

enter image description here

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

Answer 1

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

请注意，在图片中，您可以从右下角到左上角对齐。因此，在该图片中，他们并未真正对齐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();
}

Answer 2

看看http://en.wikipedia.org/wiki/Longest_common_substring，代码几乎是多种语言的复制粘贴，并且很容易适应也告诉你对齐索引。我不得不做类似的事情，结果是https://github.com/Pomax/DOM-diff/blob/rewrite/rewrite/rewrite.html#L103

（它返回的SubsetMapping基本上是一个简单的结构，为两个上下文提供索引，https://github.com/Pomax/DOM-diff/blob/rewrite/rewrite/rewrite.html#L52）

全局序列对齐动态规划在矩阵中找到最小值

2 个答案: