分治法是一種非常通用的算法設計技巧. 在很多實際問題中, 相比直接求解, 分治法往往能顯著降低算法的計算復雜度. 常見的可以用分治法求解的問題有: 排序, 矩陣乘法, 整數乘法, 離散傅里葉變換等. 分治法的一般思路如下:

1. [Divide] 把原問題拆分成同類型的子問題.
2. [Conquer] 用遞歸的方式求解子問題.
3. [Combine] 根據子問題的解構造原問題的解.

分治法最關鍵的步驟是如何 低成本地 利用子問題的解構來造原問題的解. 它包含兩個方面: 1. 可行性, 即, 可以用子問題的解來構造原問題的解; 2. 高效性, 即構造原問題解的時間復雜度較低. 換句話說, 分治法需要比直接求解效率高. 分治法一般是通過遞歸求解子問題, 其時間復雜度的分析需要用到如下定理.

Master Theorem^[1]. 考慮遞歸式. 當, 時, 我們有

Counting Inversions^[2]

在推薦場景中, 一個常用的方法是協同過濾(Collaborative Filtering), 即為相似的用戶推薦它們共同喜歡的事物. 以推薦歌曲為例, 我們把用戶和對歌曲的偏好分別進行排序, 然后計算有多少首歌在和的排序是"不同的". 最后根據這種不同來定義用戶和的相似性, 從而進行歌曲推薦. 具體來說, 對用戶對歌曲的偏好按編號. 用戶對歌曲的偏好可以表示為

對任意的, 如果, 我們稱和稱為 反序(inversion). 換句話說, 用戶A把歌曲排在歌曲的前面, 但是用戶B把歌曲排在了歌曲的前面.

問題描述

給定無重復數字的整數序列, 計算其反序的數量.

算法設計

直接求解的思路是考慮所有的二元組并判斷它們是否反序. 這個算法的時間復雜度是. 下面我們用分治法來降低計算復雜度.

注意到這個問題實際上與排序非常類似. 通過對序列進行排序的同時記錄不滿足"順序"的二元組數量, 即反序的數量. 令. 把序列分成兩部分:

用遞歸的方式對left和right進行排序, 同時計算left和right中的反序數量. 當序列的長度為1時, 返回0. 下一步是合并子問題的解. 注意到left和right已經是按照從小到大的順序進行排列. 比較left和right的第一個元素并把較小的元素添加到結果中直到left或right為空, 最后再把剩余的序列添加到結果集. 在比較過程中我們需要記錄反序的數量. 當right中的元素小于left中的元素時, 反序的增量為"left中剩余元素的數量". 最終的結果包含三部分之和: left中反序的數量, rihgt中反序的數量和合并時反序的數量.

Python實現

整體的計算過程.

def sort_and_count(x):
    if len(x) == 1:
        return x, 0
    k = len(x) // 2
    left, count_left = sort_and_count(x[0: k])
    right, count_right = sort_and_count(x[k:])
    # 把子問題的解拼接成原問題的解
    combined, count = merge_and_count(left, right)
    return combined, count + count_left + count_right

歸并過程.

def merge_and_count(left, right):
    """ 把left和right合并且計算inversion的數量
    注意: left和right已經排好序
    """
    combined = []
    count = 0
    while len(left) and len(right):
        if left[0] > right[0]:  # 反序(左邊的編號小于右邊的編號是正序)
            combined.append(right.pop(0))
            count += len(left)
        else:  # 正序
            combined.append(left.pop(0))
    return combined + left + right, count

完整代碼

計算復雜度

容易分析歸并過程的時間復雜度是. 令代表算法的時間復雜度, 我們有

根據Master Theorem, 我們得到.

Closest Pair^[2]

Closest Pair是計算幾何里的一個基本問題: 給定二維平面上的個點, 找到距離最近的兩個點. 通過計算任意兩點的距離可以在找到距離最近的兩點. 下面利用分治法可以把時間復雜度降低到.

算法設計

如果所有點是一維的, 我們可以把它們排序, 然后計算所有相鄰兩點的最小距離. 排序耗時, 計算相鄰點的最小距離耗時, 因此算法的時間復雜度為. 在二維情形, 我們的思路是類似的:

1. 沿著軸方向對點集進行排序得到.

2. 把按與軸垂的方向均分成兩部分和:
   

3. 遞歸地求解和中的closest pair(如下圖所示).

   image

4. 根據和的計算結果構造原問題的解(見下文).

合并(Combine)

設, 分別是和中的closest pair. 如果的closest pair在或中, 我們只需要從和選擇距離小的pair作為結果輸出. 否則的closest pair其中一點在中, 另一點在中, 這時我們需要比較和中的點. 這樣一來, 合并的時間復雜度為! 接下來我們要把合并的時間復雜度降低為.

令, 其中代表, 兩點之間的距離. 設 代表和的分割線. 如果存在, 使得, 那么和在軸方向距離一定不超過. 令, 因此. 如下圖所示, 中的點在藍色虛線之間.
[圖片上傳失敗...(image-facf8c-1586865336187)]
把中的點按軸從小到大排序, 得到集合, 其中是一個二元組(代表它在平面中的位置). 我們有如下定理(稍后給出證明):

定理 如果存在滿足, 那么.

這樣一來, 我們可以在的時間內找到所有距離不超過的點對, 并記錄距離最小的點對作為結果輸出(如果存在). 思路思路如下:

pairs_within_delta = []  # S中距離不超過delta的點的集合
for s in Sy:
    for t in 15 points after s:
        if d(s, t) < delta:
            add (s,t) to pairs_within_delta
output the minimum distance pair in pairs_within_delta

求解子問題和之前, 首先把根據軸從小到大排序得到, 這樣一來可以在時間內構造, 即依次過濾掉中距離超過的點. 在上述算法中, 外層循環次數是, 內層循環是常數, 因此在合并步驟中構造closest pair的時間復雜度最終降低為.

Python實現

先把輸入點集分別按軸和軸排序, 得到和. 遞歸求解的過程參考函數closest_pair_xy.

def closest_pair(points):
    """ 計算二維點集中的closest pair.
    :param points: P = [(x1,y1), (x2,y2), ..., (xn, yn)]
    :return: 兩個距離最近的點
    """
    
    # 把P按x軸和y軸分別進行排序, 得到Px和Py
    # 注意: P, Px, Py 三個集合是相同的(僅僅排序不同)
    Px = sorted(points, key=lambda item: item[0])
    Py = sorted(points, key=lambda item: item[1])
    return closest_pair_xy(Px, Py)
    
    
def closest_pair_xy(Px, Py):
    """ 計算closest pair
    :param Px: 把points按x軸升序排列
    :param Py: 把points按y軸升序排列
    :return: point1, point2
    """
    if len(Px) <= 3:
        return search_closest_pair(Px)
    # 構造子問題的輸入: Qx, Rx, Qy, Ry
    k = len(Px) // 2
    Q, R = Px[0: k], Px[k:]
    Qx, Qy = sorted(Q, key=lambda x: x[0]), sorted(Q, key=lambda x: x[1])
    Rx, Ry = sorted(R, key=lambda x: x[0]), sorted(R, key=lambda x: x[1])
    # 求解子問題
    q0, q1 = closest_pair_xy(Qx, Qy)
    r0, r1 = closest_pair_xy(Rx, Ry)
    # 合并子問題的解
    return combine_results_of_sub_problems(Py, Qx, q0, q1, r0, r1)


def search_closest_pair(points):
    """ 用枚舉的方式尋找closest pair
    :param points: [(x1,y1), (x2,y2), ...]
    :return: closest pair
    """
    n = len(points)
    dist_min, i_min, j_min = math.inf, 0, 0
    for i in range(n-1):
        for j in range(i+1, n):
            d = get_dist(points[i], points[j])
            if d < dist_min:
                dist_min, i_min, j_min = d, i, j
    return points[i_min], points[j_min]


def get_dist(a, b):
    """ 計算兩點之間的歐式距離
    """
    return math.sqrt(math.pow(a[0]-b[0], 2) + math.pow(a[1]-b[1], 2))

設代表closest_pair_xy的計算時間. 根據前文分析, 合并子問題的解并輸出原問題的解的時間復雜度為, 因此我們有

根據Master Theorem, 我們有. 此外, 把分別按軸排序的時間復雜度為, 因此算法整體的時間復雜度是.

下面是合并過程的實現.

def combine_results_of_sub_problems(Py, Qx, q0, q1, r0, r1):
    """
    :param Py: P按y軸排序的結果
    :param Qx: P在x=x0處被切分成Q和R. Qx是Q按x軸排序的結果
    :param q0: (q0, q1)是Q中的closest pair
    :param q1: 參考q0
    :param r0: (r0, r1)是R中的closest pair
    :param r1: 參考r0
    :return: closest pair in P
    """
    # 計算Sy
    d = min(get_dist(q0, q1), get_dist(r0, r1))
    Sy = get_sy(Py, Qx, d)
    # 檢查是否存在距離更小的pair
    s1, s2 = closest_pair_of_sy(Sy)
    if s1 and s2 and get_dist(s1, s2) < d:
        return s1, s2
    elif get_dist(q0, q1) < get_dist(r0, r1):
        return q0, q1
    else:
        return r0, r1


def get_sy(Py, Qx, d):
    """ 根據Py計算Sy.
    :param Py: P按y軸排序的結果
    :param Qx: P在x=x0處被切分成Q和R. Qx是Q按x軸排序的結果
    :param d: delta
    :return: S
    """
    x0 = Qx[-1][0]  # Q最右邊點的x坐標值
    return [p for p in Py if p[0] - x0 < d]


def closest_pair_of_sy(Sy):
    """ 計算集合Sy的closest pair
    """
    n = len(Sy)
    if n <= 1:
        return None, None
    dist_min, i_min, j_min = math.inf, 0, 0
    for i in range(n-1):
        for j in range(i + 1, i + 16):
            if j == len(Sy):
                break
            d = get_dist(Sy[i], Sy[j])
            if d < dist_min:
                dist_min, i_min, j_min = d, i, j
    return Sy[i_min], Sy[j_min]

完整代碼

定理證明

定理 如果存在滿足, 那么.

根據前文的描述, 已知中的點在下圖藍色虛線之間. 把中的點按軸從小到大排序得到, 其中代表平面中的一個點. 為了方便描述, 我們把下圖中藍色虛線之間用單位長度為的網格劃分.
[圖片上傳失敗...(image-dad441-1586865336187)]
假設存在使得. 我們要證明. 證明分為兩步:

1. 和必須在不同的網格中. 反證法. 假設在同一個網格中(意味著 or ), 它們的距離. 注意是和中的最短距離, 因此矛盾.
2. . 反證法. 假設. 如上圖所示和之間至少相差3行(網格). 因此, 矛盾.

參考文獻

1. T.H. Cormen, C. E. Leiserson, R.L. Rivest and C. Stein. Introduction to Algorithms. Third edition. The MIT Press, 2009. ?

2. J. Kleinberg and E. Tardos. Algorithm Design. Pearson, 2006. ? ?