比對演算法
❶ 比較演算法優缺點：
1.先來先服務先來先服務（FCFS, First Come First Serve）是最簡單的調度演算法，按先後順序進行調度。1. 定義按照作業提交或進程變為就緒狀態的先後次序，分派CPU；當前作業或進程佔用CPU，直到執行完或阻塞，才出讓CPU（非搶占方式）。在作業或進程喚醒後（如I/O完成），並不立即恢復執行，通常等到當前作業或進程出讓CPU。2.適用場景比較有利於長作業，而不利於短作業。有利於CPU繁忙的作業，而不利於I/O繁忙的作業。
2. 輪轉法輪轉法(Round Robin)是讓每個進程在就緒隊列中的等待時間與享受服務的時間成正比例。1. 定義將系統中所有的就緒進程按照FCFS原則，排成一個隊列。每次調度時將CPU分派給隊首進程，讓其執行一個時間片。時間片的長度從幾個ms到幾百ms。在一個時間片結束時，發生時鍾中斷。調度程序據此暫停當前進程的執行，將其送到就緒隊列的末尾，並通過上下文切換執行當前的隊首進程。進程可以未使用完一個時間片，就出讓CPU（如阻塞）。2. 時間片長度的確定時間片長度變化的影響過長－>退化為FCFS演算法，進程在一個時間片內都執行完，響應時間長。過短－>用戶的一次請求需要多個時間片才能處理完，上下文切換次數增加，響應時間長。對響應時間的要求：T(響應時間)=N(進程數目)*q(時間片)就緒進程的數目：數目越多，時間片越小系統的處理能力：應當使用戶輸入通常在一個時間片內能處理完，否則使響應時間，平均周轉時間和平均帶權周轉時間延長。
3. 多級反饋隊列演算法多級反饋隊列演算法(Round Robin with Multiple Feedback)是輪轉演算法和優先順序演算法的綜合和發展。1. 定義設置多個就緒隊列，分別賦予不同的優先順序，如逐級降低，隊列1的優先順序最高。每個隊列執行時間片的長度也不同，規定優先順序越低則時間片越長，如逐級加倍。新進程進入內存後，先投入隊列1的末尾，按FCFS演算法調度；若按隊列1一個時間片未能執行完，則降低投入到隊列2的末尾，同樣按FCFS演算法調度；如此下去，降低到最後的隊列，則按「時間片輪轉」演算法調度直到完成。僅當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程執行。如果進程執行時有新進程進入較高優先順序的隊列，則搶先執行新進程，並把被搶先的進程投入原隊列的末尾。2.優點為提高系統吞吐量和縮短平均周轉時間而照顧短進程。為獲得較好的I/O設備利用率和縮短響應時間而照顧I/O型進程。不必估計進程的執行時間，動態調節3. 幾點說明I/O型進程：讓其進入最高優先順序隊列，以及時響應I/O交互。通常執行一個小時間片，要求可處理完一次I/O請求的數據，然後轉入到阻塞隊列。計算型進程：每次都執行完時間片，進入更低級隊列。最終採用最大時間片來執行，減少調度次數。I/O次數不多，而主要是CPU處理的進程。在I/O完成後，放回優先I/O請求時離開的隊列，以免每次都回到最高優先順序隊列後再逐次下降。為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。
4. 優先順序法優先順序演算法（Priority Scheling）是多級隊列演算法的改進，平衡各進程對響應時間的要求。適用於作業調度和進程調度，可分成搶先式和非搶先式。1. 靜態優先順序作業調度中的靜態優先順序大多按以下原則確定：由用戶自己根據作業的緊急程度輸入一個適當的優先順序。由系統或操作員根據作業類型指定優先順序。系統根據作業要求資源情況確定優先順序。進程的靜態優先順序的確定原則：按進程的類型給予不同的優先順序。將作業的情態優先順序作為它所屬進程的優先順序。2. 動態優先順序進程的動態優先順序一般根據以下原則確定：根據進程佔用有CPU時間的長短來決定。根據就緒進程等待CPU的時間長短來決定。
5．短作業優先法短作業優先（SJF, Shortest Job First）又稱為「短進程優先」SPN(Shortest Process Next)；這是對FCFS演算法的改進，其目標是減少平均周轉時間。1. 定義對預計執行時間短的作業（進程）優先分派處理機。通常後來的短作業不搶先正在執行的作業。2. SJF的特點(1) 優點：比FCFS改善平均周轉時間和平均帶權周轉時間，縮短作業的等待時間；提高系統的吞吐量；(2) 缺點：對長作業非常不利，可能長時間得不到執行；未能依據作業的緊迫程度來劃分執行的優先順序；難以准確估計作業（進程）的執行時間，從而影響調度性能。3. SJF的變型「最短剩餘時間優先」SRT(Shortest Remaining Time)（允許比當前進程剩餘時間更短的進程來搶占）「最高響應比優先」HRRN(Highest Response Ratio Next)（響應比R = (等待時間 + 要求執行時間) / 要求執行時間，是FCFS和SJF的折衷）6. 最高響應比優先法最高響應比優先法(HRN，Highest Response_ratio Next)是對FCFS方式和SJF方式的一種綜合平衡。FCFS方式只考慮每個作業的等待時間而未考慮執行時間的長短，而SJF方式只考慮執行時間而未考慮等待時間的長短。因此，這兩種調度演算法在某些極端情況下會帶來某些不便。HRN調度策略同時考慮每個作業的等待時間長短和估計需要的執行時間長短，從中選出響應比最高的作業投入執行。響應比R定義如下： R =(W+T)/T = 1+W/T其中T為該作業估計需要的執行時間，W為作業在後備狀態隊列中的等待時間。每當要進行作業調度時，系統計算每個作業的響應比，選擇其中R最大者投入執行。這樣，即使是長作業，隨著它等待時間的增加，W / T也就隨著增加，也就有機會獲得調度執行。這種演算法是介於FCFS和SJF之間的一種折中演算法。由於長作業也有機會投入運行，在同一時間內處理的作業數顯然要少於SJF法，從而採用HRN方式時其吞吐量將小於採用SJF 法時的吞吐量。另外，由於每次調度前要計算響應比，系統開銷也要相應增加。
❷ 序列比對的演算法過程
實際操作中利用計算機程序實現序列比對的基本演算法。序列比對不僅需要考慮子序列之間的匹配，而且需要對整個序列進行比較。也就是說，必須考慮兩個序列中所有殘基的匹配。這就意味著，不可能使所有殘基都能嚴格匹配。在這種情況下，序列比對中確定空位的過程變得十分復雜。
在進行序列兩兩比對時，有兩方面問題直接影響相似性分值：取代矩陣和空位罰分。 空位罰分是為了補償插入和缺失對序列相似性的影響，由於沒有什麼合適的理論模型能很好地描述空位 問題，因此空位罰分缺乏理論依據而更多的帶有主觀特色。一般的處理方法是用兩個罰分值，一個對插入的第一個空位罰分，如10－15；另一個對空位的延伸罰分，如1－2。對於具體的比對問題，採用不同的罰分方法會取得不同的效果。
對於比對計算產生的分值，到底多大才能說明兩個序列是同源的，對此有統計學方法加以說明，主要的思想是把具有相同長度的隨機序列進行比對，把分值與最初的比對分值相比，看看比對結果是否具有顯著性。相關的參數E代表隨機比對分值不低於實際比對分值的概率。對於嚴格的比對，必須E值低於一定閾值才能說明比對的結果具有足夠的統計學顯著性，這樣就排除了由於偶然的因素產生高比對得分的可能。
❸ 什麼是多序列全局比對的累進演算法（三個步驟）
第一，所有的序列之間逐一比對（雙重比對）；第二，生成一個系統樹圖，將序列按相似性大致分組；第三，使用系統樹圖作為引導，產生出最終的多序列比對結果。
❹ 怎麼判斷比較各種演算法的好壞
首先，這個演算法必須是正確的
其次，好的演算法應該是友好的，便於人們理解和交流，並且是機器可執行的。
這個演算法還需要足夠健壯，即當輸入的數據非法或不合理時，也能適當的做出正確的反應或進行相應的處理
最後它還必須擁有高效率和低存儲量要求。
也就是樓上幾位說的時間復雜度和空間復雜度
占的地方越小，算得越快的演算法才是好演算法。
❺ 圖像比對的原理或者演算法
有雜訊情況下。1、配准；2、兩張圖的圖像塊分別計算特徵（lbp,sift等）；3、計算特徵的距離（歐式距離等）。在matlab或opencv下都可以。
❻ 序列比對的演算法有哪些在應用上各有何特點
首先你要明白——Clustalx的多序列比對演算法是基於雙序列比對的，它先將所有序列兩兩比對，然後根據兩兩比對結果構建指導樹，再根據指導樹依次添加相似度最高的
❼ 文本比較有哪些演算法
用java比較兩個文本文件的不同
RangeDifferencer
public class RangeDifferencer {
private static final RangeDifference[] EMPTY_RESULT= new RangeDifference[0];
/* (non Javadoc)
* Cannot be instantiated!
*/
private RangeDifferencer() {
// nothing to do
}
/**
* Finds the differences between two <code>IRangeComparator</code>s.
* The differences are returned as an array of <code>RangeDifference</code>s.
* If no differences are detected an empty array is returned.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences, or an empty array if no differences were found
*/
public static RangeDifference[] findDifferences(IRangeComparator left, IRangeComparator right) {
int rightSize= right.getRangeCount();
int leftSize= left.getRangeCount();
//
// Differences matrix:
// only the last d of each diagonal is stored, i.e., lastDiagonal[k] = row of d
//
int diagLen= 2 * Math.max(rightSize, leftSize); // bound on the size of edit script
int maxDiagonal= diagLen;
int lastDiagonal[]= new int[diagLen + 1]; // the row containing the last d
// on diagonal k (lastDiagonal[k] = row)
int origin= diagLen / 2; // origin of diagonal 0
// script corresponding to d[k]
LinkedRangeDifference script[]= new LinkedRangeDifference[diagLen + 1];
int row, col;
// find common prefix
for (row= 0; row < rightSize && row < leftSize && rangesEqual(right, row, left, row) == true;)
row++;
lastDiagonal[origin]= row;
script[origin]= null;
int lower= (row == rightSize) ? origin + 1 : origin - 1;
int upper= (row == leftSize) ? origin - 1 : origin + 1;
if (lower > upper)
return EMPTY_RESULT;
//System.out.println("findDifferences: " + maxDiagonal + " " + lower + " " + upper);
// for each value of the edit distance
for (int d= 1; d <= maxDiagonal; ++d) { // d is the current edit distance
if (right.skipRangeComparison(d, maxDiagonal, left))
return EMPTY_RESULT; // should be something we already found
// for each relevant diagonal (-d, -d+2 ..., d-2, d)
for (int k= lower; k <= upper; k += 2) { // k is the current diagonal
LinkedRangeDifference edit;
if (k == origin - d || k != origin + d && lastDiagonal[k + 1] >= lastDiagonal[k - 1]) {
//
// move down
//
row= lastDiagonal[k + 1] + 1;
edit= new LinkedRangeDifference(script[k + 1], LinkedRangeDifference.DELETE);
} else {
//
// move right
//
row= lastDiagonal[k - 1];
edit= new LinkedRangeDifference(script[k - 1], LinkedRangeDifference.INSERT);
}
col= row + k - origin;
edit.fRightStart= row;
edit.fLeftStart= col;
//Assert.isTrue(k >= 0 && k <= maxDiagonal);
script[k]= edit;
// slide down the diagonal as far as possible
while (row < rightSize && col < leftSize && rangesEqual(right, row, left, col) == true) {
++row;
++col;
}
//Assert.isTrue(k >= 0 && k <= maxDiagonal); // Unreasonable value for diagonal index
lastDiagonal[k]= row;
if (row == rightSize && col == leftSize) {
//showScript(script[k], right, left);
return createDifferencesRanges(script[k]);
}
if (row == rightSize)
lower= k + 2;
if (col == leftSize)
upper= k - 2;
}
--lower;
++upper;
}
// too many differences
//Assert.isTrue(false);
return null;
}
/**
* Finds the differences among two <code>IRangeComparator</code>s.
* In contrast to <code>findDifferences</code>, the result
* contains <code>RangeDifference</code> elements for non-differing ranges too.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences
*/
public static RangeDifference[] findRanges(IRangeComparator left, IRangeComparator right) {
RangeDifference[] in= findDifferences(left, right);
List out= new ArrayList();
RangeDifference rd;
int mstart= 0;
int ystart= 0;
for (int i= 0; i < in.length; i++) {
RangeDifference es= in[i];
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, es.rightStart() - mstart, ystart, es.leftStart() - ystart);
if (rd.maxLength() != 0)
out.add(rd);
out.add(es);
mstart= es.rightEnd();
ystart= es.leftEnd();
}
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, right.getRangeCount() - mstart, ystart, left.getRangeCount() - ystart);
if (rd.maxLength() > 0)
out.add(rd);
return (RangeDifference[]) out.toArray(EMPTY_RESULT);
}
//---- private methods
/*
* Creates a Vector of DifferencesRanges out of the LinkedRangeDifference.
* It coalesces adjacent changes.
* In addition, indices are changed such that the ranges are 1) open, i.e,
* the end of the range is not included, and 2) are zero based.
*/
private static RangeDifference[] createDifferencesRanges(LinkedRangeDifference start) {
LinkedRangeDifference ep= reverseDifferences(start);
ArrayList result= new ArrayList();
RangeDifference es= null;
while (ep != null) {
es= new RangeDifference(RangeDifference.CHANGE);
if (ep.isInsert()) {
es.fRightStart= ep.fRightStart + 1;
es.fLeftStart= ep.fLeftStart;
RangeDifference b= ep;
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fRightStart= ep.fRightStart;
es.fLeftStart= ep.fLeftStart;
RangeDifference a= ep;
//
// deleted lines
//
do {
a= ep;
ep= ep.getNext();
es.fRightLength++;
} while (ep != null && ep.isDelete() && ep.fRightStart == a.fRightStart + 1);
boolean change= (ep != null && ep.isInsert() && ep.fRightStart == a.fRightStart);
if (change) {
RangeDifference b= ep;
//
// replacement lines
//
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fLeftLength= 0;
}
es.fLeftStart++; // meaning of range changes from "insert after", to "replace with"
}
//
// the script commands are 1 based, subtract one to make them zero based
//
es.fRightStart--;
es.fLeftStart--;
result.add(es);
}
return (RangeDifference[]) result.toArray(EMPTY_RESULT);
}
/*
* Tests if two ranges are equal
*/
private static boolean rangesEqual(IRangeComparator a, int ai, IRangeComparator b, int bi) {
return a.rangesEqual(ai, b, bi);
}
/*
* Tests whether <code>right</code> and <code>left</code> changed in the same way
*/
private static boolean rangeSpansEqual(IRangeComparator right, int rightStart, int rightLen, IRangeComparator left, int leftStart, int leftLen) {
if (rightLen == leftLen) {
int i= 0;
for (i= 0; i < rightLen; i++) {
if (!rangesEqual(right, rightStart + i, left, leftStart + i))
break;
}
if (i == rightLen)
return true;
}
return false;
}
/*
* Reverses the range differences
*/
private static LinkedRangeDifference reverseDifferences(LinkedRangeDifference start) {
LinkedRangeDifference ep, behind, ahead;
ahead= start;
ep= null;
while (ahead != null) {
behind= ep;
ep= ahead;
ahead= ahead.getNext();
ep.setNext(behind);
}
return ep;
}
}
下面是一段關於如何使用這些類的簡單的測試代碼
public class RangeDifferencerTest extends TestCase {
InputStream left = null;
InputStream right = null;
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
String file1 = "d:/temp/1.txt";
String file2 = "d:/temp/2.txt";
left = new FileInputStream(new File(file1));
right = new FileInputStream(new File(file2));
super.setUp();
}
/**
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
left.close();
right.close();
super.tearDown();
}
public static void main(String[] args) {
}
/*
* Test method for 'com.greatroad.smbnm.compare.RangeDifferencer.findDifferences(IRangeComparator, IRangeComparator)'
*/
public void testFindDifferences() {
try {
RangeDifference[] rds = RangeDifferencer.findRanges(new LineComparator(left,"GBK"),new LineComparator(right,"GBK"));
if(rds != null ){
for(int i=0; i<rds.length; i++){
RangeDifference rd = rds[i];
int length = rd.leftLength();
System.out.println(
"kind = "+rd.kind()
+",left["+rd.leftStart()+"-"+rd.leftEnd()
+"],right["+rd.rightStart()+"-"+rd.rightEnd()+"]");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
❽ 如何比較兩個演算法的好壞，有什麼指標
演算法是一個良定義的計算過程，以一個或多個值輸入，並以一個或多個值輸出。
評價演算法的好壞的因素：·演算法是正確的；
·執行演算法的時間；
·執行演算法的存儲空間（主要是輔助存儲空間）；
·演算法易於理解、編碼、調試。
**************************************************************************************************************
時間復雜度：是某個演算法的時間耗費，它是該演算法所求解問題規模n的函數。
漸近時間復雜度：是指當問題規模趨向無窮大時，該演算法時間復雜度的數量級。
評價一個演算法的時間性能時，主要標准就是演算法的漸近時間復雜度。
演算法中語句的頻度不僅與問題規模有關，還與輸入實例中各元素的取值相關。
時間復雜度按數量級遞增排列依次為：常數階O(1)、對數階O(log2n)、線性階O(n)、線性對數階O(nlog2n)、平方階O(n^2)、立方階O(n^3)、……k次方階O(n^k)、指數階O(2^n)。
空間復雜度：是某個演算法的空間耗費，它是該演算法所求解問題規模n的函數。
演算法的時間復雜度和空間復雜度合稱演算法復雜度。
❾ 數據快速比較演算法
你想知道每位相不相同嗎？我看你這是二級制數吧，如果是二進制可以用位運算的異或，相同為0，不同為1，這是最快的了，時間復雜度為O(1)，掩碼的操作都是用位運算的，不用什麼查找。
如果你不知道位運算是啥，還是自己網路一下吧
❿ 詳細介紹雙序列比對、blast 以及多序列比對的區別,以及均適用於哪些場 景
序列比對是將兩個或多個序列排列在一起，標明其相似之處。使用間隔表示未比對上，比對上的相同或相似的符號排列在同一列上。序列比對是生物信息學以及基因組學與進化的基礎之一，其基本思想是：在生物學中普遍存在的序列決定結構、結構決定功能的規律，通過將核酸序列或者蛋白質序列的一級結構看成由基本字元構成的字元串，通過序列比對我們可以找到相似的序列並由此發現生物序列中的功能、結構和進化信息。
全局比對：全局比對是指將參與比對的兩條序列裡面的所有字元進行比對。全局比對在全局范圍內對兩條序列進行比對打分，找出最佳比對，主要被用來尋找關系密切的序列。其可以用來鑒別或證明新序列與已知序列家族的同源性，是進行分子進化分析的重要前提。其代表是Needleman-Wunsch演算法。
局部比對：與全局比對不同，局部比對不必對兩個完整的序列進行比對，而是在每個序列中使用某些局部區域片段進行比對。其產生的需求在於、人們發現有的蛋白序列雖然在序列整體上表現出較大的差異性，但是在某些局部區域能獨立的發揮相同的功能，序列相當保守。這時候依靠全局比對明顯不能得到這些局部相似序列的。其次，在真核生物的基因中，內含子片段表現出了極大變異性，外顯子區域卻較為保守，這時候全局比對表現出了其局限性，無法找出這些局部相似性序列。其代表是Smith-Waterman局部比對演算法。
雙重序列比對：雙序列比對是指對兩條序列M和N進行比對，找到其相似性關系，這種尋找生物序列相似性關系的過程被稱為雙序列比對。其演算法可以主要分成基於全局比對的Needleman-Wunsch演算法和基於局部比對的Smith-Waterman局部比對演算法
多重序列比對：多序列比對是雙序列比對推廣，即把兩個以上字元序列對齊，逐列比較其字元的異同，使得每一列字元盡可能一致，以發現其共同的結構特徵的方法稱為多序列比對。多序列比對演算法可以分成漸進法和同步法。其可以發現不同的序列之間的相似部分，從而推斷它們在結構和功能上的相似關系，主要用於分子進化關系，預測蛋白質的二級結構和三級結構、估計蛋白質折疊類型的總數，基因組序列分析等。
基因組比對：是多序列比對的一種特例，指對基因組范圍內的序列信息進行比對的過程。通過對不同親緣關系物種的基因組序列進行比較，能夠鑒定出編碼序列、非編碼調控序列及給定物種獨有的序列。而基因組范圍之內的序列比對，可以了解不同物在核苷酸組成、同線性關系和基因順序方面的異同，進而得到基因分析預測與定位、生物系統發生進化關系等方面的信息。
BLAST：BLAST[1]（Basic Local Alignment Search Tool）是在在1990年由Altschul等人提出的雙序列局部比對演算法，是一套在蛋白質資料庫或DNA資料庫中進行相似性比較的分析工具。BLAST是一種啟發式演算法，用於在大型資料庫中尋找比對序列，是一種在局部比對基礎上的近似比對演算法，可以在保持較高精度的情況下大大減少程序運行的時間。
演算法思想描述：
雙重序列比對主要分成以Needleman-Wunsch演算法為代表的全局比對和以Smith-Waterman局部比對演算法為代表的局部比對，BLAST是局部比對的一種推廣。多重比對演算法可以主要分成動態規劃演算法、隨機演算法、迭代法和漸進比對演算法。
（1）雙重序列比對：
Needleman-Wunsch演算法：該演算法是基於動態規劃思想的全局比對的基本演算法，動態規劃的比對演算法的比對過程可以用一個以序列S為列，T為行的(m+1)×(n+1)的二維矩陣來表示，用
sigma表示置換矩陣。
在計算完矩陣後，從矩陣的右下角單元到左上單元回溯最佳路徑（用箭頭表示），根據最佳路徑給出兩序列的比對結果。其中，斜箭頭表示2個殘基匹配，水平箭頭表示在序列S的相應位置插入一個空位，垂直方向的箭頭表示在序列T的相應位置插入一個空位。
Smith-Waterman演算法：該演算法是一種用來尋找並比較具有局部相似性區域的動態規劃演算法，這種演算法適用於親緣關系較遠、整體上不具有相似性而在一些較小的區域上存在局部相似性的兩個序列。該演算法的基本思想是：使用迭代方法計算出兩個序列的相似分值，存在一個得分矩陣M中，然後根據這個得分矩陣，通過動態規劃的方法回溯找到最優的比對序列。與全局比對相比，這種演算法的改變是把矩陣單元值為負者一律取為0，這是因為分值為負的比對喪失了比對的生物學意義，因此把得分為負值的子序列丟棄。
BLAST: BLAST演算法的基本思想是通過產生數量更少的但質量更好的增強點來提高比對的速度。演算法的原理主要分為以下五步：（1）過濾：首先過濾掉低復雜度區域，即含有大量重復的序列；（2）Seeding：將Query序列中每k個字組合成一個表，即將一個序列拆分成多個連續的『seed words』（通常蛋白質k=3，核酸k=11）；（3）比對：列出我們所關心的所有可能的字組，再配合置換矩陣給出高分值的字組並組織成快速搜索樹結構或者哈希索引，因此此步驟可以快速搜索出大數據集中的所有匹配序列，找到每個seed words在參考序列中的位置；（4）延伸：當找到seed words的位置後，接下來需要將seed word延伸成長片段，延伸過程中，得分值也在變化，當得分值小於閾值時即停止延伸，最後得到的片段成為高分片段對，HSP（High-scoring segment pair）；（5）顯著性分析，最後我們使用如下公式計算E值，E值衡量了在隨機情況下，資料庫存在的比當前匹配分數更好的比對的數目，因此可以用該值作為指標評價HSP比對序列的可信度。
其中，m是資料庫長度，n是query的長度，S是HSP分數，其他兩個參數是修正系數。
（2）多重序列比對
動態規劃演算法：其基本思想是將一個二維的動態規劃矩陣擴展到三維或者多維，多序列比對的積分是n個序列中兩兩進行比對所得積分之和。矩陣的維度反映了參與比對的序列數。這種方法對計算資源要求比較高[6]。
隨機演算法：主要包括遺傳演算法和模擬退火演算法，遺傳演算法是一類借鑒生物界進化規律演化來的全局意義上的自適應隨機搜索方法。當用遺傳演算法進行生物序列分析時，每一代包含固定數量的個體，這些個體用他們的適應度來評價。變異則模擬了生物進化過程中的偶然殘基突變現象。對產生的新一代群體進行重新評價、選擇、交叉、變異，如此循環往復，使群體中最優個體的適應度不斷提高，直到達到一個閾值，演算法結束。模擬退火的基本思想是用一物質系統的退火過程來模擬優化問題的尋優方法，當物質系統達到最小能量狀態時，優化問題的目標函數也相應地達到了全局最優解。這兩種方法都是對構造好的目標函數進行最優解搜索，但實際比對效果並不好[6,7]。
迭代法：迭代法的代表是Muscle[8], Muscle是一個新的漸進比對和迭代比對的綜合演算法，主要由兩部分構成，第一部分是迭代漸進比對：第一次漸進比對的目的是快速產生一個多序列比對而不強調准確率，以此為基礎再對漸進比對進行改良。經過兩次漸進比對，形成一個相對准確的多序列比對；第二部分是迭代比對：該過程類似於Prrp演算法[9]，即通過不斷的迭代，逐步優化最終比對結果。其主要特點包括：使用kmer counting進行快速的距離測量，使用一個新的圖譜比對打分函數進行漸進比對，使用依賴於數的有限分隔進行細化。
漸進比對演算法：該演算法以Feng和Doolittle提出的最為經典[10]。漸進比對演算法的基本思想是迭代地利用兩序列動態規劃比對演算法,先由兩個序列的比對開始，逐漸添加新序列，直到所有序列都加入為止。但是不同的添加順序會產生不同的比對結果。確定合適的比對順序是漸進比對演算法的一個關鍵問題。通常，整個序列的比對應該從最相似的兩個序列開始，由近至遠逐步完成。作為全局多序列比對的漸進比對演算法有個基本的前提假設:所有要比對的序列是同源的，即由共同的祖先序列經過一系列的突變積累，並經自然選擇遺傳下來的，分化越晚的序列之間相似程度就越高。因此，在漸進比對過程中，應該對近期的進化事件比遠期的進化事件給予更大的關注。由於同源序列是進化相關的，因此可以按著序列的進化順序，即沿著系統發育樹(指導樹)的分支，由近至遠將序列或已比對序列按雙序列比對演算法逐步進行比對，重復這一過程直到所有序列都己添加到這個比對中為止[10]。其三個步驟為：（1）利用雙序列比對方法對所有的序列進行兩兩比對，得到相似性分值；（2）利用相似性矩陣（或距離矩陣）產生輔助導向樹；（3）根據導向樹進行漸進比對。漸進比對演算法是最常用、簡單又有效的啟發式多序列比對方法，它所需時間較短、所佔內存較小，其演算法很多，主要有CLUSTAL W, T-Coffee和DiAlign等，其中 CLUSTAL W應用最廣泛。
應用：
類型+應用
雙重序列對比：判斷兩個序列的同源性和一致性。（1）全局多序列比對可以鑒別或證明新序列與己有序列家族的同源性;幫助預測新蛋白質序列的二級和二級結構，是進行分子進化分析的重要前提。適合序列相似性較高，序列長度近似時的比對；（2）局部比對考慮序列部分區域的相似性。局部多序列比對可以用來刻畫蛋白質家族和超家族。適合於未知兩個序列相似程度的，可能存在一些片段極其相似而另一些片段相異的序列比對情況。
多重序列比對：多重比對經常用來研究序列間的進化關系，構建進化樹；探究序列間的保守性。主要用於分子進化關系，預測蛋白質的二級結構和三級結構、估計蛋白質折疊類型的總數，基因組序列分析等。
基因組比對：通過對不同親緣關系物種的基因組序列進行比較，能夠鑒定出編碼序列、非編碼調控序列及給定物種獨有的序列。而基因組范圍之內的序列比對，可以了解不同物在核苷酸組成、同線性關系和基因順序方面的異同，進而得到基因分析預測與定位、生物系統發生進化關系等方面的信息。
其中，BLAST作為最重要的比對工具，意義特殊，拿出來單獨討論。BLAST可以分成Basic BLAST和 Specialized BLAST, BLAST包括常規的nucleotide blast, Protein blast和Translating blast；Specialize blast可以對特殊生物或特殊研究領域的序列資料庫進行檢索。