死磕一週算法，我讓服務性能提升50%

前言

我最近一直在公司作檢索性能優化。當我看到這個算法以前，我也不認爲我負責的檢索系統性能還有改進的餘地。可是這個算法確實太牛掰了，足足讓服務性能提升50%，我不得不和你們分享一下。其實前一段時間的博客中也寫到過這個算法，只是沒有細講，今天我準備把它單獨拎出來，說道說道。說實話，本人數學功底通常，算法證實不是我強項，因此文中的證實只是我在論文做者的基礎上加入了本身的思考方法，而且尚未徹底證實出來，請你們見諒 ! 歡迎愛思考的小夥伴進行補充。我只要達到拋磚引玉的做用，就滿足了。

迴歸正題，咱們的檢索服務中用到了最小編輯距離算法，這個算法自己是平方量級的時間複雜度，而且不多人在帖子中提到小於這個複雜度的算法。可是我無心中發現了另一個更牛的算法：列劃分算法，使得這個本就很牛的算法性能直接提升一倍。接下來進入正題。

列劃分算法

這個算法比較難理解，出自以下論文：《Theoretical and empirical comparisons of approximate string matching algorithms》。In Proceedings of the 3rd Annual Symposium on Combinatorial Pattern Matching, number 664 in Lecture Notes in Computer Science, pages 175~184. Springer-Verlag, 1992。Author:WI Chang ，J Lampe。因此有必要先給你們普及一些共識。

編輯矩陣 最小編輯距離在計算過程當中使用動態規劃算法計算的那個矩陣，瞭解這個算法的都懂，我不贅述。可是咱們的編輯矩陣有個特色：第一行都是0，這麼作的好處是：只要文本串T中的任意一個子序列與模式串P的編輯距離小於某個固定的數值，就會被發現。

給大夥一個樣例，文本串T=annealing，模式串P=annual：

注意，第一行都是0，這是與傳統最小編輯距離的最大區別，其他的動歸方程徹底相同。

對角線法則 編輯矩陣沿着右下方對角線方向數值非遞減，而且至多相差1。

行列法則 每行每列相鄰兩個數至多相差1。

觀察編輯距離矩陣，咱們發現以下事實：每一列是由若干段連續數字組成。因此咱們把編輯矩陣的每一列劃分紅若干連續序列，以下圖所示：

紅色框中就是一個一個的序列，序列內部連續。

序列-δ 定義 對於編輯矩陣的每個元素D[j][i] (j是行，i是列)，若 j - D[j][i] = δ，咱們就說D[j][i]屬於i列上的 序列-δ，咱們還觀察到隨着j增大，j - D[j][i]是非遞減的。以下圖所示：

序列-δ終止位置 每一個序列都會有起始和終止位置。序列-δ的終止位置爲j，若是j是序列-δ的最小橫座標，而且知足D[j+1][i]屬於序列-ε，而且ε>δ（即j+1-D[j+1][i]>δ）。

長度爲0的序列 咱們發現若是按照如上定義，每一列上δ的值並不必定連續，老是或有或無的缺乏一個數值。因此咱們定義長度爲0的序列：當D[j+1][i] < D[j][i]時，咱們就在序列-δ和序列-(δ+2)之間人爲插入一個長度爲0的序列-(δ+1)。以下圖所示：

因此，咱們按照這個定義，就能夠對編輯矩陣的每列進行一個劃分，劃分的每一段都是一串連續數字。

說了這麼多，這個定義有什麼用呢？倘若，咱們每次都能根據前一列的列劃分狀況直接推導出後一列的列劃分狀況，那麼就能夠省去好多計算，畢竟每個劃分中的每一段的數字都是連續的，這就暗示咱們能夠直接用一個常數時間的加法直接獲得某一個編輯矩陣的元素值，而不用使用最小編輯距離的動態規劃算法去計算。

接下來的重點來了，咱們介紹這個推導公式，請打起十二分精神！咱們按照序列-δ長度是否爲0來介紹這個推論。因爲其中一個推論文字描述太繁瑣，不容易理解，因此我畫了個圖：

接下來燒腦開始。

推論1：若是列i上長度爲0的 序列-δ 的結束位置爲j，則列i+1上的 序列-δ 的結束位置爲 j+1。

證實 ：由推論前提咱們知道 δ = j - D[j][i] + 1 （想一想前面說的δ值不連續，咱們就人爲插入一箇中間值，只不過長度爲0）。
咱們觀察編輯矩陣就會發現以下兩個事實：

• 事實1：D[j+1][i+1] = D[j][i] （ 別問爲何， 本身觀察， 看看是否是都這樣， 其實能夠用反證法，咱們就不證實了）。

• 事實2：D[j+2][i+1] <= D[j][i]。

經過事實1，咱們知道D[j+1][i+1]確實屬於 序列-δ，由於 j + 1 - D[j+1][i+1] = j + 1 - D[j][i] = δ。

經過事實2，咱們知道列i+1上的序列δ，終止位置爲j+1。

因此推論1證實結束。

推論2： 文字描述略，請看圖

證實 ：

• 設這個序列長度爲L，除了每列的第一個序列外，其他序列的其他位置均是當前的編輯距離小於等於該列上一個位置的編輯距離：即D[j-L+1][i]<=D[j-L][i]，因此，咱們能夠推出：D[j-L+1][i] <= D[j-L][i];

• 再根據編輯矩陣對角線非遞減咱們知道，D[j-L+1][i+1] >= D[j-L][i];

綜上兩點咱們獲得以下大小關係：D[j-L+1][i+1] >= D[j-L+1][i]。

此外咱們知道咱們當前列的序列-δ截止位置爲j，也意味着D[j+1][i] <= D[j][i]，一樣根據對角線法則，咱們得出D[j+2][i+1] <= D[j+1][i] + 1 <= D[j][i] + 1。

接下來到了最精彩的一步，咱們知道列i當前序列-δ內的值是連續的，若是起始編輯距離爲A，那麼終止編輯距離爲A+L-1。

而由咱們的推導能夠發現：D[j-L+1][i+1] >= A，D[j+2][i+1] <= (A+L-1) + 1 = A+L，而之間跨越的長度爲 (j+2)-(j-L+1)+1= L+2。 咱們能夠推出列i+1上從行j-L+1到行j+2之間的序列必定不連續，不然D[j+2][i+1] >= A+L+2-1= A+L+1，與咱們先前的推導矛盾。因此，在j-L+1和j+2之間必定有一個列終止，這樣才能消去一個序號。

此外咱們還有一個疑問，列i+1上的序列-δ結束位置必定在j-L+1和j+1之間麼？咱們要證實這個事。

證實 ：

由於δ=j-D[j][i]=j-L+1-D[j-L+1][i]>=j-L+1-D[j-L+1][i+1]，即列i+1上的 序列-δ的結束位置必定在j-L+1或者以後；

因爲j+1-D[j+1][i]>δ，根據對角線法則D[j+2][i+1] <= D[j+1][i]+1，有j+2-D[j+2][i+1]>=j+2-(D[j+1][i]+1)=j+1-D[j+1][i] > δ， 固列i+1上的序列-δ的終止位置必定在j+2以前，即j-L+1到j+1之間。

後面推論2的分狀況討論，我一個也沒證實出來，做者在論文中輕飄飄的一句話「後面很好證實，他就不去證實了」，可是卻消耗了我全部腦細胞。因此，若是哪位小夥伴把推論2剩下的內容證實出來了，歡迎給我留言，我也學習學習。

這個算法的時間複雜度是多少呢？做者用啓發式的方法證實了算法的複雜度約爲$ O(mn/\sqrt[2]{b}) $，其中b是字符集大小。

代碼實現

接下來講一下代碼實現，給出我總結出來的步驟，不然很容易踩坑。

• 編輯矩陣第一列，確定只有一個序列。
• 每次遍歷前一列的全部序列，根據推論1和推論2計算後一列的劃分狀況。
• 若是前一列遍歷完畢，可是下一列還有剩餘的元素沒有劃分。不要緊，下一列剩下的元素都歸爲一個新的序列。
• 預處理一個表，表中記錄T中的每一個字符在P中的位置。能夠直接用哈希算法（最好直接ascii碼）進行定位，若是位置不惟一，能夠拉鍊。進行列劃分計算時，從前日後遍歷那一鏈上的位置，直到找到第一個符合條件的，速度出奇的快。儘量少使用或者不要使用map進行定位，測試發現至關慢。

接下來作最不肯意作的事：貼一個代碼，很醜。

inline int loc(int find[][200], int *len, int ch, int pos) {
  for(int i = 0; i < len[ch]; ++i) {
    if(find[ch][i] >= pos)  return find[ch][i];
  }
  return -1;
}

int new_column_partition(char *p, char *t) {
  int len_p = strlen(p);
  int len_t = strlen(t);
  int find[26][200];
  int len[26] = {0};
  int part[200];  //記錄每個序列的結束位置
  //生成loc表，用來快速查詢
  for(int i = 0; i < len_p; ++i) {
    find[p[i] - 'a'][len[p[i] - 'a']++] = i + 1;
  }
  
  int pre_cn = 0, next_cn = 1, min_v = len_p;
  part[0] = len_p;
  
  for(int i = 0; i < len_t; ++i) {
    //前一列partition數
    pre_cn = next_cn;
    next_cn = 0;
    int l = part[0] + 1;
    int b = 1;
    int e = l;
    int tmp;
    int tmp_value = 0;
    int pre_v = part[0];
    //前一列第0個partition長度確定>=1
    if(len[t[i] - 'a'] >0 && (tmp = loc(find, len, t[i] - 'a', b)) != -1 && tmp <= e) {
      part[next_cn++] = tmp - 1;
    } else if(pre_cn >= 2 && part[1] - part[0] != 0){
      part[next_cn++] = part[0] + 1;
    } else {
      part[next_cn++] = part[0];
    }
    //每列第一個partition尾值
    tmp_value = part[0];

    //遍歷前一列剩下的partition
    for(int j = 1; j < pre_cn && part[next_cn - 1] < len_p; ++j) {
      int x = part[j], y = pre_v;
      pre_v = part[j];
      l = x - y;
      if(l == 0) {
        part[next_cn++] = x + 1;
      } else {
        b = x - l + 2;
        e = x + 1;
        if(b <= len_p && len[t[i] - 'a'] > 0 && (tmp = loc(find, len, t[i] - 'a', b)) != -1 && tmp <= e) {
          part[next_cn++] = tmp - 1;
        } else if(j + 1 < pre_cn && part[j + 1] - x != 0) {
          part[next_cn++] = x + 1;
        } else {
          part[next_cn++] = x;
        }
      }
      l = part[j] - part[j - 1];
      if(l == 0) {
        //新獲得的partition長度爲0，那麼下一個partition的起始值比上一個partition尾值少1
        tmp_value -= 1;
      } else {
        tmp_value += l - 1;
      }
    }
    
    if(part[next_cn - 1] != len_p) {
      part[next_cn++] = len_p;  
      tmp_value += len_p - part[next_cn - 2] - 1;
      if(tmp_value < min_v) {
        min_v = tmp_value;
      }
    } else {
      min_v = min_v < tmp_value ? min_v : tmp_value;
    }
  }
  return min_v;
}

結語

這個算法應用到線上以後，效果很是明顯，以下對比。

• 優化前CPU：
  
• 優化後CPU：
  

能力有限，證實不充分，有興趣的小果伴能夠直接去看原版論文，歡迎交流，共同進步。