序列比对算法-计算生物学

最新推荐文章于 2024-02-29 14:05:28 发布
最新推荐文章于 2024-02-29 14:05:28 发布
阅读量1w 收藏 33
点赞数 4
分类专栏： ML/DL 文章标签： 生物信息学 算法 序列比对
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SoundSlow/article/details/78175015
版权

1.序列比对指将两个或多个序列排列在一起，标明其相似之处。序列中可以插入间隔（通常用短横线“-”表示）。对应的相同或相似的符号（在核酸中是A, T(或U), C, G，在蛋白质中是氨基酸残基的单字母表示）排列在同一列上。这一方法常用于研究由共同祖先进化而来的序列，特别是如蛋白质序列或DNA序列等生物序列。进行相似度分析。
这里写图片描述

2.分类

  • 全局比对：将两个序列中的所有字符都进行依次比对，由于各方面的缺陷，可用性不强。
  • 局部比对（local alignment）：通过动态规划的方式，改动最少来匹配两个序列最相似的部分。
  • 双序列比对：只需要比对两个序列
  • 多序列比对：基于双序列比对，这样，主要是用来提取多个不同序列中，具有的共同特征信息。

3.双序列局部比对。

  • 最大子序列问题，对于两个字符串，通过比较找到两个字符串中相同的子序列，不考虑间隔。
/**
 1. Design an algorithm to find the Longest Common Subsequence,
 Longest Common Substring between two sequences.
 * Created by zoutai on 2017/10/1.
 * 从后向前遍历查找，迭代/遍历+动态规划
 * 但是递归的方式有一个坏处，就是内部往往那个存在很多重复计算，最大时间复杂度2^n
 * 所以我们采用空间换时间的办法:直接将所有的L[i][j]遍历出来，时间复杂度即为（mn）
 */
public class LongestCommonSubsequence {
    public static void main(String[] args) {
        String s1 = "AGGTAB";
        String s2 = "GXTXAYB";
        int m = s1.length(),n=s2.length();
        String result = getLongestSubStr(s1,s2,m,n);
        System.out.println(result);
    }

    // 从后向前遍历
    public static String getLongestSubStr(String s1,String s2,int m,int n) {
        if (m == 0 || n == 0)
            return "";
        if (s1.charAt(m - 1) == s2.charAt(n - 1))
            return getLongestSubStr(s1, s2, m - 1, n - 1)+s1.charAt(m - 1);
        else
            return max(getLongestSubStr(s1, s2, m, n - 1), getLongestSubStr(s1, s2, m - 1, n));
    }

    // 比较字符串长度
    public static String max(String a, String b) {
        if(a==null||b==null){
            return "";
        }
        return (a.length() > b.length()) ? a : b;
    }
}
  • Smith-Waterman算法:
    算法主要思想：
    对于A,B两个序列，n,m分别表示他们的长度，构造相应的矩阵和罚分；通过罚分矩阵，得到分数最大的一条路径，即为做好的匹配路径。
    参考链接：wiki
    这里写图片描述
    实现方式：
    • 普通空白函数：
import java.util.LinkedList;
import java.util.List;

/**
 * Created by zoutai on 2017/10/2.
 * 2.Tandem repeats. Let P be a pattern of length n and T a text of length m.
 * Let Pm be the concatenation of P with itself m times, so Pm has length mn.
 * We want to compute a local alignment between Pm and T .
 */

public class Alignment02 {
    public static void main(String[] args) {
        List<String> list = new LinkedList<String>();

        /* 样例1：
        输出为：
            G-CTAGCT
            GACTA-CT
         */
        String P = new String("AGCT");
        String T = new String("GACTACT");
        String Pm = new String();
        Pm = pToPm(P,T);
        list = localAlig(Pm,T);

        /* (不复制)样例2：
        输出为：
            GTT-AC
            GTTGAC
         */
//      String t1 = new String("TGTTACGG");
//      String t2 = new String("GGTTGACTA");
//        list = localAlig(t1, t2);

        for (String str : list) {
            System.out.println(str.toString());
        }
    }

    private static List<String> localAlig(String A, String B) {
        List<String> twoList = new LinkedList<String>();
        int allMax = 0;
        int col = A.length();
        int row = B.length();
        int[][] mat = new int[row + 1][col + 1];
        for (int i = 0; i < col + 1; i++) {
            mat[0][i] = 0;
        }
        for (int j = 0; j < row + 1; j++) {
            mat[j][0] = 0;
        }
        for (int i = 1; i < col+1; i++) {
            for (int j = 1; j < row+1; j++) {
                int Match = mat[j - 1][i - 1] + (B.charAt(j-1)==A.charAt(i-1)?3:-3);
                int Delete = mat[j - 1][i] + (0 - 2);
                int Insert = mat[j][i - 1] + (0 - 2);
                mat[j][i] = Math.max(Math.max(Match,0), Math.max(Insert, Delete));
            }
        }

        // 再次遍历矩阵，获取矩阵最大值，用于查找序列初始点
        int tempMax = 0;
        int temprow =0,tempcol = 0;
        for (int i =0;i<row+1;i++) {
            for (int j =0;j<col+1;j++) {
                System.out.print(mat[i][j]+".");
                if (tempMax < mat[i][j]) {
                    tempMax = mat[i][j];
                    temprow = i;
                    tempcol = j;
                }
            }
            System.out.println();
        }

        String AlignmentA = "";
        String AlignmentB = "";
        int i = tempcol;
        int j = temprow;
        while (i > 0 && j > 0) {
            if (i > 0 && j > 0 && mat[j][i] == mat[j-1][i-1]
                    + (B.charAt(j-1)==A.charAt(i-1)?3:-3)) {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                i = i - 1;
                j = j - 1;
            } else if (i == 1 || j == 1) {
                break;
            } else if (j > 0 && mat[j][i] == mat[j - 1][i] + (0 - 2)) {
                AlignmentA = "-" + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                j = j - 1;
            } else {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = "-" + AlignmentB;
                i = i - 1;
            }
        }
        twoList.add(AlignmentA);
        twoList.add(AlignmentB);
        return twoList;
    }

    // 将p字符串转为pm
    private static String pToPm(String p, String t) {
        // TODO Auto-generated method stub
        int n = p.length();
        int m = t.length();
        StringBuffer sb = new StringBuffer();
        for (int i=0;i<m;i++) {
            sb.append(p);
        }
        return sb.toString();
    }
}

* 线性空白函数：

import java.util.LinkedList;
import java.util.List;

/**
 * Created by zoutai on 2017/10/2.
 * Implementation of simple local alignment algorithm
 *
 * 线性罚分，Ws=2;Wd=0;
 */
public class Alignment0301 {
    public static final int[][] PAM250 = {
            {4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0},
            {-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3},
            {-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3},
            {-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3},
            {0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1},
            {-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2},
            {-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2},
            {0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3},
            {-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3},
            {-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3},
            {-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1},
            {-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2},
            {-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1},
            {-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1},
            {-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2},
            {1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2},
            {0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0},
            {-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3},
            {-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1},
            {0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4}};

    public static void main(String[] args) {
        String t1 = new String("TGTTACGG");
        String t2 = new String("GGTTGACTA");
        List<String> list = new LinkedList<String>();
        list = localAlig(t1, t2);
        for (String str : list) {
            System.out.println(str.toString());
        }
    }

    private static List<String> localAlig(String A, String B) {
        List<String> twoList = new LinkedList<String>();
        int allMax = 0;
        int col = A.length();
        int row = B.length();
        int[][] mat = new int[row + 1][col + 1];
        for (int i = 0; i < col + 1; i++) {
            mat[0][i] = 0;
        }
        for (int j = 0; j < row + 1; j++) {
            mat[j][0] = 0;
        }
        for (int i = 1; i < col+1; i++) {
            for (int j = 1; j < row+1; j++) {
                int Match = mat[j - 1][i - 1] + (B.charAt(j-1)==A.charAt(i-1)?3:-3);
                int Delete = mat[j - 1][i] + (0 - 2);
                int Insert = mat[j][i - 1] + (0 - 2);
                mat[j][i] = Math.max(Math.max(Match,0), Math.max(Insert, Delete));
            }
        }

        // 再次遍历矩阵，获取矩阵最大值，用于查找序列初始点
        int tempMax = 0;
        int temprow =0,tempcol = 0;
        for (int i =0;i<row+1;i++) {
            for (int j =0;j<col+1;j++) {
                System.out.print(mat[i][j]+".");
                if (tempMax < mat[i][j]) {
                    tempMax = mat[i][j];
                    temprow = i;
                    tempcol = j;
                }
            }
            System.out.println();
        }

        String AlignmentA = "";
        String AlignmentB = "";
        int i = tempcol;
        int j = temprow;
        while (i > 1 && j > 1) {
            if (i > 1 && j > 1 && mat[j][i] == mat[j-1][i-1]
                    + (B.charAt(j-1)==A.charAt(i-1)?3:-3)) {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                i = i - 1;
                j = j - 1;
            } else if (i == 1 || j == 1) {
                break;
            } else if (j > 1 && mat[j][i] == mat[j - 1][i] + (0 - 2)) {
                AlignmentA = "-" + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                j = j - 1;
            } else {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = "-" + AlignmentB;
                i = i - 1;
            }
        }
        twoList.add(AlignmentA);
        twoList.add(AlignmentB);
        return twoList;
    }
}

* Affine空白函数：

import java.util.LinkedList;
import java.util.List;

/**
 * Created by zoutai on 2017/10/2.
 * Implementation the classical affine-gap local alignment algorithm
 *
 * Affine罚分，Ws=2;Wd=10;
 */
public class Alignment0302 {

    public static final int[][] PAM250 = {
            {4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0},
            {-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3},
            {-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3},
            {-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3},
            {0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1},
            {-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2},
            {-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2},
            {0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3},
            {-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3},
            {-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3},
            {-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1},
            {-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2},
            {-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1},
            {-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1},
            {-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2},
            {1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2},
            {0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0},
            {-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3},
            {-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1},
            {0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4}};

    public static void main(String[] args) {
        String t1 = new String("TGTTACGG");
        String t2 = new String("GGTTGACTA");
        List<String> list = new LinkedList<String>();

        list = localAlig(t1, t2);

        for (String str : list) {
            System.out.println(str.toString());
        }
    }

    private static List<String> localAlig(String A, String B) {
        List<String> twoList = new LinkedList<String>();
        int allMax = 0;
        int col = A.length();
        int row = B.length();
        int[][] mat = new int[row + 1][col + 1];
        for (int i = 0; i < col + 1; i++) {
            mat[0][i] = -10;
        }
        for (int j = 0; j < row + 1; j++) {
            mat[j][0] = -10;
        }
        for (int i = 1; i < col+1; i++) {
            for (int j = 1; j < row+1; j++) {
                int Match = mat[j - 1][i - 1] + Scoring.getScore(PAM250, A.charAt(i - 1), B.charAt(j - 1));
                int Delete = mat[j - 1][i] + (0 - 2);
                int Insert = mat[j][i - 1] + (0 - 2);
                mat[j][i] = Math.max(Math.max(Match,0), Math.max(Insert, Delete));
            }
        }

        // 再次遍历矩阵，获取矩阵最大值，用于查找序列初始点
        int tempMax = 0;
        int temprow =0,tempcol = 0;
        for (int i =0;i<row+1;i++) {
            for (int j =0;j<col+1;j++) {
                System.out.print(mat[i][j]+".");
                if (tempMax < mat[i][j]) {
                    tempMax = mat[i][j];
                    temprow = i;
                    tempcol = j;
                }
            }
            System.out.println();
        }

        String AlignmentA = "";
        String AlignmentB = "";
        int i = tempcol;
        int j = temprow;
        while (i > 1 && j > 1) {
            if (i > 1 && j > 1 && mat[j][i] == mat[j-1][i-1]
                    + Scoring.getScore(PAM250, A.charAt(i - 1), B.charAt(j - 1))) {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                i = i - 1;
                j = j - 1;
            } else if (i == 1 || j == 1) {
                break;
            } else if (j > 1 && mat[j][i] == mat[j - 1][i] + (0 - 2)) {
                AlignmentA = "-" + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                j = j - 1;
            } else {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = "-" + AlignmentB;
                i = i - 1;
            }
        }
        twoList.add(AlignmentA);
        twoList.add(AlignmentB);
        return twoList;
    }
}

* 其中给定罚分矩阵：

import java.util.HashMap;

//This stores scoring resources, including matrices

public class Scoring {

    //matrix contents are from rosalind:
     public static final int[][] BLOSUM62 = {
         { 4,  0, -2, -1, -2,  0, -2, -1, -1, -1, -1, -2, -1, -1, -1,  1,  0,  0, -3, -2},
         { 0,  9, -3, -4, -2, -3, -3, -1, -3, -1, -1, -3, -3, -3, -3, -1, -1, -1, -2, -2},
         {-2, -3,  6,  2, -3, -1, -1, -3, -1, -4, -3,  1, -1,  0, -2,  0, -1, -3, -4, -3},
         {-1, -4,  2,  5, -3, -2,  0, -3,  1, -3, -2,  0, -1,  2,  0,  0, -1, -2, -3, -2},
         {-2, -2, -3, -3,  6, -3, -1,  0, -3,  0,  0, -3, -4, -3, -3, -2, -2, -1,  1,  3},
         { 0, -3, -1, -2, -3,  6, -2, -4, -2, -4, -3,  0, -2, -2, -2,  0, -2, -3, -2, -3},
         {-2, -3, -1,  0, -1, -2,  8, -3, -1, -3, -2,  1, -2,  0,  0, -1, -2, -3, -2,  2},
         {-1, -1, -3, -3,  0, -4, -3,  4, -3,  2,  1, -3, -3, -3, -3, -2, -1,  3, -3, -1},
         {-1, -3, -1,  1, -3, -2, -1, -3,  5, -2, -1,  0, -1,  1,  2,  0, -1, -2, -3, -2},
         {-1, -1, -4, -3,  0, -4, -3,  2, -2,  4,  2, -3, -3, -2, -2, -2, -1,  1, -2, -1},
         {-1, -1, -3, -2,  0, -3, -2,  1, -1,  2,  5, -2, -2,  0, -1, -1, -1,  1, -1, -1},
         {-2, -3,  1,  0, -3,  0,  1, -3,  0, -3, -2,  6, -2,  0,  0,  1,  0, -3, -4, -2},
         {-1, -3, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2,  7, -1, -2, -1, -1, -2, -4, -3},
         {-1, -3,  0,  2, -3, -2,  0, -3,  1, -2,  0,  0, -1,  5,  1,  0, -1, -2, -2, -1},
         {-1, -3, -2,  0, -3, -2,  0, -3,  2, -2, -1,  0, -2,  1,  5, -1, -1, -3, -3, -2},
         { 1, -1,  0,  0, -2,  0, -1, -2,  0, -2, -1,  1, -1,  0, -1,  4,  1, -2, -3, -2},
         { 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1,  0, -1, -1, -1,  1,  5,  0, -2, -2},
         { 0, -1, -3, -2, -1, -3, -3,  3, -2,  1,  1, -3, -2, -2, -3, -2,  0,  4, -3, -1},
         {-3, -2, -4, -3,  1, -2, -2, -3, -3, -2, -1, -4, -4, -2, -3, -3, -2, -3, 11,  2},
         {-2, -2, -3, -2,  3, -3,  2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1,  2,  7}};


    //This following matrix is copied from rosalind:
    public static final int[][] PAM250 = {
            {4,-1,-2,-2,0,-1,-1,0,-2,-1,-1,-1,-1,-2,-1,1,0,-3,-2,0},
            {-1,5,0,-2,-3,1,0,-2,0,-3,-2,2,-1,-3,-2,-1,-1,-3,-2,-3},
            {-2,0,6,1,-3,0,0,0,1,-3,-3,0,-2,-3,-2,1,0,-4,-2,-3},
            {-2,-2,1,6,-3,0,2,-1,-1,-3,-4,-1,-3,-3,-1,0,-1,-4,-3,-3},
            {0,-3,-3,-3,9,-3,-4,-3,-3,-1,-1,-3,-1,-2,-3,-1,-1,-2,-2,-1},
            {-1,1,0,0,-3,5,2,-2,0,-3,-2,1,0,-3,-1,0,-1,-2,-1,-2},
            {-1,0,0,2,-4,2,5,-2,0,-3,-3,1,-2,-3,-1,0,-1,-3,-2,-2},
            {0,-2,0,-1,-3,-2,-2,6,-2,-4,-4,-2,-3,-3,-2,0,-2,-2,-3,-3},
            {-2,0,1,-1,-3,0,0,-2,8,-3,-3,-1,-2,-1,-2,-1,-2,-2,2,-3},
            {-1,-3,-3,-3,-1,-3,-3,-4,-3,4,2,-3,1,0,-3,-2,-1,-3,-1,3},
            {-1,-2,-3,-4,-1,-2,-3,-4,-3,2,4,-2,2,0,-3,-2,-1,-2,-1,1},
            {-1,2,0,-1,-3,1,1,-2,-1,-3,-2,5,-1,-3,-1,0,-1,-3,-2,-2},
            {-1,-1,-2,-3,-1,0,-2,-3,-2,1,2,-1,5,0,-2,-1,-1,-1,-1,1},
            {-2,-3,-3,-3,-2,-3,-3,-3,-1,0,0,-3,0,6,-4,-2,-2,1,3,-1},
            {-1,-2,-2,-1,-3,-1,-1,-2,-2,-3,-3,-1,-2,-4,7,-1,-1,-4,-3,-2},
            {1,-1,1,0,-1,0,0,0,-1,-2,-2,0,-1,-2,-1,4,1,-3,-2,-2},
            {0,-1,0,-1,-1,-1,-1,-2,-2,-1,-1,-1,-1,-2,-1,1,5,-2,-2,0},
            {-3,-3,-4,-4,-2,-2,-3,-2,-2,-3,-2,-3,-1,1,-4,-3,-2,11,2,-3},
            {-2,-2,-2,-3,-2,-1,-2,-3,2,-1,-1,-2,-1,3,-3,-2,-2,2,7,-1},
            {0,-3,-3,-3,-1,-2,-2,-3,-3,3,1,-2,1,-1,-2,-2,0,-3,-1,4}};

    public static HashMap<Character, Integer> matrixIndex = new HashMap<>();

    //initializing values for the matrices, as they are arranged here:
    static {
        matrixIndex.put('A', 0);
        matrixIndex.put('C', 1);
        matrixIndex.put('D', 2);
        matrixIndex.put('E', 3);
        matrixIndex.put('F', 4);
        matrixIndex.put('G', 5);
        matrixIndex.put('H', 6);
        matrixIndex.put('I', 7);
        matrixIndex.put('K', 8);
        matrixIndex.put('L', 9);
        matrixIndex.put('M', 10);
        matrixIndex.put('N', 11);
        matrixIndex.put('P', 12);
        matrixIndex.put('Q', 13);
        matrixIndex.put('R', 14);
        matrixIndex.put('S', 15);
        matrixIndex.put('T', 16);
        matrixIndex.put('V', 17);
        matrixIndex.put('W', 18);
        matrixIndex.put('Y', 19);
    }

    // returns the score of a match between the two provided amino acids, as scored by the specified matrix:
    public static int getScore(int[][] matrix, char reference, char search) {
        reference = Character.toUpperCase(reference);
        search = Character.toUpperCase(search);

        return matrix[matrixIndex.get(reference)][matrixIndex.get(search)]; 
    }

}

* 对文本进行处理测试：

import java.io.*;
import java.util.LinkedList;
import java.util.List;

/**
 * Created by zoutai on 2017/10/2.
 */
public class TestAlignment03 {

    public static final int[][] PAM250 = {
            {4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0},
            {-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3},
            {-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3},
            {-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3},
            {0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1},
            {-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2},
            {-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2},
            {0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3},
            {-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3},
            {-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3},
            {-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1},
            {-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2},
            {-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1},
            {-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1},
            {-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2},
            {1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2},
            {0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0},
            {-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3},
            {-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1},
            {0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4}};

    public static void main(String[] args) throws FileNotFoundException,IOException{
        File txtFile = new File("data_hm.txt");
        BufferedReader br = new BufferedReader(new FileReader(txtFile));
        int lineNumber = 0;
        String line = null;
        StringBuffer t1 = new StringBuffer();
        StringBuffer t2 = new StringBuffer();
        List strArr1 = new LinkedList();
        List strArr2 = new LinkedList();
        int[] resultArr = new int[25];

        Boolean first = true;
        Boolean flag = true;
        int isget = 1;
        while ((line = br.readLine())!=null) {
            if(first) {
                first = false;
                continue;
            } else if(line.equals("")) {
                first = true;
                if(isget==2) {
                    strArr1.add(t1);
                    strArr2.add(t2);
                    t1 = new StringBuffer();
                    t2 = new StringBuffer();
                    isget--;
                    continue;
                }
                isget++;
                flag = !flag;
            } else {
                if(flag) {
                    t1.append(line);
                } else {
                    t2.append(line);
                }
            }
        }
        List<String> list = new LinkedList<String>();
        System.out.println(strArr1.size());
        for (int i =0;i<25;i++) {
            System.out.println(strArr1.get(i).toString());
            System.out.println(strArr2.get(i).toString());
            System.out.println();
            resultArr[i] = localAlig(strArr1.get(i).toString(), strArr2.get(i).toString());
        }
        System.out.println(resultArr);
        for (int score: resultArr) {
            System.out.println(score);
        }
    }

    private static int localAlig(String A, String B) {
        List<String> twoList = new LinkedList<String>();
        int allMax = 0;
        int col = A.length();
        int row = B.length();
        int[][] mat = new int[row + 1][col + 1];
        for (int i = 0; i < col + 1; i++) {
            mat[0][i] = -10;
        }
        for (int j = 0; j < row + 1; j++) {
            mat[j][0] = -10;
        }
        for (int i = 1; i < col+1; i++) {
            for (int j = 1; j < row+1; j++) {
                int Match = mat[j - 1][i - 1] + Scoring.getScore(PAM250, A.charAt(i - 1), B.charAt(j - 1));
                int Delete = mat[j - 1][i] + (0 - 2);
                int Insert = mat[j][i - 1] + (0 - 2);
                mat[j][i] = Math.max(Math.max(Match,0), Math.max(Insert, Delete));
            }
        }

        // 再次遍历矩阵，获取矩阵最大值，用于查找序列初始点
        int tempMax = 0;
        int temprow =0,tempcol = 0;
        for (int i =0;i<row+1;i++) {
            for (int j =0;j<col+1;j++) {
                System.out.print(mat[i][j]+".");
                if (tempMax < mat[i][j]) {
                    tempMax = mat[i][j];
                    temprow = i;
                    tempcol = j;
                }
            }
            System.out.println();
        }
        System.out.println(tempMax);
        String AlignmentA = "";
        String AlignmentB = "";
        int i = tempcol;
        int j = temprow;
        while (i > 1 && j > 1) {
            if (i > 1 && j > 1 && mat[j][i] == mat[j-1][i-1]
                    + Scoring.getScore(PAM250, A.charAt(i - 1), B.charAt(j - 1))) {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                i = i - 1;
                j = j - 1;
            } else if (i == 1 || j == 1) {
                break;
            } else if (j > 1 && mat[j][i] == mat[j - 1][i] + (0 - 2)) {
                AlignmentA = "-" + AlignmentA;
                AlignmentB = B.charAt(j - 1) + AlignmentB;
                j = j - 1;
            } else {
                AlignmentA = A.charAt(i - 1) + AlignmentA;
                AlignmentB = "-" + AlignmentB;
                i = i - 1;
            }
        }
        twoList.add(AlignmentA);
        twoList.add(AlignmentB);
        //return twoList;
        return tempMax;
    }
}

第一题：查找最长子序列
第二题：序列比较算法，使用最普通的方式，Ws = 2, Wd = 0, 无罚分矩阵，默认（相等：不相等）=（+3，-1）
第三题：相对于第二题，添加了罚分矩阵PAM250,(20*20);同时simple local alignment algorithm使用线性罚分，Wd=0,Ws=2;
affine-gap local alignment algorithm使用affine罚分，Wd=10,Ws=2。

一题：求两个序列的最长公共子序列或子串（动态规划）
参考链接：http://www.geeksforgeeks.org/longest-common-subsequence/

第二题：
参考：https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm
https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm#Example

第三题：
参考github用户：https://github.com/hswaffield/Linear-Space-Local-Alignment
http://www.cs.utexas.edu/~mobios/cs329e/rosetta/src/Blosum.java
https://en.wikipedia.org/wiki/Gap_penalty#Affine
https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm#Gap_penalty

相关资料连接链接：http://pan.baidu.com/s/1nvaENdn 密码：gmyf

随风而醒
关注
  • 4
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生物信息序列比对算法
04-27
生物信息学的研究重点主要体现在基因组学和蛋白质学两方面,具体地说就是从核酸和蛋白质序列出发, 分析序列中表达结构和功能的生物信息。生物信息学的基本任务是对各种生物分析序列进行分析, 也就是研究新的计算机方法, 从大量的序列信息中获取基因结构、功能和进化等知识。而在序列分析中, 将未知序列同已知序列进行相似性比较是一种强有力的研究手段,从序列的片段测定, 拼接, 基因的表达分析, 到RNA和蛋白质的结构功能预测。物种亲缘树的构建都需要进行生物分子序列的相似性比较。生物信息学中的序列比对算法的研究具有非常重要的理论意义和实践意义。
两序列比对算法与软件研究进展
03-06
两序列比对是一种基本序列分析方法,广泛用于序列之间的相似性分析和数据库同源性搜索。现今,用于两序列的软件有上百种,它们应用不同的算法或针对不同的序列类型,在比对速度和比对质量等方面也有很大的差异。根据要比对的序列情况以及要达到的目的选择合适的比对软件是非常有必要的。对现有两序列比对的算法和常用软件进行归类和比较,为研究人员了解现今序列比对情况,筛选合适的比对算法和软件提供参考。
【学习笔记】山东大学生物信息学-02 序列比较
abdslfwoeugp
06-08 4044
山东大学生物信息学-02 序列比较
怎么在知网上查论文重复率
最新发布
Rtee1的博客
02-29 358
在使用知网查询论文重复率时，还需要注意以下几点：首先，保持高度的学术诚信，遵守学术规范和法律法规；最后，多参考相关文献和资料，增加论文的创新性和独特性。同时，建议在写作过程中注重文献引用和标注的规范性，以避免不必要的重复和误解。通过以上七个方面的介绍，相信你已经掌握了在知网上查询论文重复率的方法和技巧。使用知网的在线编辑器进行修改和调整，确保论文的原创性和质量。这份报告会列出论文中重复的内容和相似文献来源，以及相应的重复率数据。根据你的论文类型和用途，选择合适的检测版本。上传完成后，系统会自动开始检测。
基于短序列分组和拼接策略的子序列快速查询算法
04-30
子序列查询技术在金融、商业、医疗等领域均有重要应用，但因DTW等相似性比对算法的时间复杂度较高，子序列长度对检索时间影响很大，限制了数据集上长子序列检索的效率。针对这一问题提出一种子序列快速查询算法。首先对数据集中特定长度下所有子序列进行分组并标记出代表性子序列；然后在查询时将查询序列切分成定长的小段序列，并用DTW算法确定与小段序列相似的代表子序列候选集；最后对候选集进行序列拼接，获取到查询结果序列。实验表明新算法效率较典型算法提高约10倍。
序列比对现状
03-17
NULL 博文链接：https://bachelor007.iteye.com/blog/549638
序列比对算法
weixin_40543542的博客
04-22 3581
目录01 序列比对中的基本概念02 利用动态规划进行全局比对新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 Pairwise Sequence Alignment 双序列比对 给定两个序列，判断其相似性。相似的序列可能有相
序列比对
qq_41475583的博客
03-04 5190
1、什么是序列比对？ 为确定两个或多个序列之间的相似性以至于同源性，而将它们按照一定的规律排列。 参考-》百度百科 2、双序列比对的基本概念 从s到t，和t到s，他们的分数是一样的。其他类似 与上下文无关 空位：对应序列中发生片段的插入或删除，也就是indel(insertion、deletion)，通常会对序列的功能产生影响，所以空位在对比过程中总是对应于一个负分，也就是所谓的空位罚分(Gap...
双序列比对
m0_70166478的博客
03-05 2288
本文学习自罗静初老师写的双序列比对的论文
转录组入门（5）： 序列比对
weixin_34372728的博客
07-19 1500
欢迎来GitHub上fork，一起进步： https://github.com/xuzhougeng 比对软件很多，首先大家去收集一下，因为我们是带大家入门，请统一用hisat2，并且搞懂它的用法。 直接去hisat2的主页下载index文件即可，然后把fastq格式的reads比对上去得到sam文件。 接...
序列比对（alignment）
wendy_r的博客
06-08 4664
序列比对 NCBI BLAST MEGA 系统发育树
全局子序列比对 Global Sequence Alignment
08-22
全局子序列比对 Global Sequence Alignment
生物序列比对算法研究现状与展望
12-26
序列比对是生物信息学研究的一个基本方法 ,寻求更快更灵敏的序列比对算法一直是生物信息学 研究的热点.本文给出了生物序列比对问题的定义 ,综述了目前常用的各类比对算法 ,并对每一类算法的 优缺点以及应用范围进行...
生物序列比对
04-26
生物信息学的研究重点主要体现在基因组学和蛋白质学两方面,具体地说就是从核酸和蛋白质序列出发, 分析序列中表达结构和功能的生物信息。...生物信息学中的序列比对算法的研究具有非常重要的理论意义和实践意义。
论文研究-求解多重序列比对问题的蚁群算法.pdf
07-22
多重序列比对是生物信息学特别是生物序列分析中一个重要的基本操作。提出求解多重序列比对问题的蚁群算法，利用人工蚂蚁逐个选择各个序列中的字符进行配对。在算法中，蚂蚁根据信息素、字符匹配得分以及位置偏差等...
激活函数、BP反向传播算法、三种梯度下降、softmax函数及其推导
SoundSlow的博客
10-03 4539
激活函数的作用： 由于我们使用的神经网络分类器是线性方程，如w1x1+w2x2+…+wnxn + bi= 0，这种方程所划分的区域总是直线类似的/折线，这种划分不能很好的划分曲面形状，所以通过引入激活函数，这种激活函数不同于一次函数，它是一种曲线，由此划分出来的界限或者高维界面就是一种曲线或者曲面，能够更好的拟合分解。 参考文章：形象的解释神经网络激活函数的作用是什么？ BP方向传播算法：
机器学习实战-8预测数值型数据-回归
SoundSlow的博客
11-25 3312
回归和分类是机器学习两个主要的类别，通常会在面试的时候，被询问这两者之间的区别。对于我，有时候我也无法说清，虽然我感觉我已经弄懂了，但是这里还是说一说自己的理解。首先，我们学过一本书《随机过程》，这里面讲到了马尔科夫链等，这是一种在时间、位置等有序列属性的数据，也就是说，这些说句不仅仅存在关系，而且存在一种序列上的前后关系，如时间、地理位置等。而分类一般核心不在于此。所以，回归问题就是一种序列预测问
深度学习优化器Optimizer总结-tensorflow-1原理篇
SoundSlow的博客
09-19 3172
单纯以算法为论，深度学习从业者的算法能力可能并不需要太大，因为很多时候，只需要构建合理的框架，直接使用框架是不需要太理解其中的算法的。但是我们还是需要知道其中的很多原理，以便增加自身的知识强度，而优化器可能正是深度学习的算法核心 本文基本完全参考一下连接： 原理简化讲解篇：https://morvanzhou.github.io/tutorials/machine-learning/ML-i...
比对算法和序列分析算法
04-05
其中最常用的是序列比对算法，例如全局比对算法和局部比对算法。这些算法通常用于比较DNA或蛋白质序列之间的相似性，以寻找共同的进化关系或功能域。比对算法还可以用于基因组比对，其中不同物种的基因组进行比较，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值