python 實現分治法的幾個例子

分治法所能解決的問題一般具有以下幾個特征：

1) 該問題的規模縮小到一定的程度就可以容易地解決

2) 該問題可以分解為若干個規模較小的相同問題，即該問題具有最優子結構性質。

3) 利用該問題分解出的子問題的解可以合並為該問題的解；

4) 該問題所分解出的各個子問題是相互獨立的，即子問題之間不包含公共的子子問題。

第一條特征是絕大多數問題都可以滿足的，因為問題的計算復雜性一般是隨着問題規模的增加而增加；

第二條特征是應用分治法的前提它也是大多數問題可以滿足的，此特征反映了遞歸思想的應用；、

第三條特征是關鍵，能否利用分治法完全取決於問題是否具有第三條特征，如果具備了第一條和第二條特征，而不具備第三條特征，則可以考慮用貪心法或動態規划法。

第四條特征涉及到分治法的效率，如果各子問題是不獨立的則分治法要做許多不必要的工作，重復地解公共的子問題，此時雖然可用分治法，但一般用動態規划法較好。

題目1. 給定一個順序表，編寫一個求出其最大值的分治算法。

# 基本子算法（子問題規模小於等於 2 時）
def get_max(max_list):
    return max(max_list) # 這里偷個懶！


# 分治法 版本一
def solve(init_list):
    n = len(init_list)
    if n <= 2: # 若問題規模小於等於 2，最終解決
        return get_max(init_list)

    # 分解（子問題規模為 2，最后一個可能為 1）
    temp_list=(init_list[i:i+2] for i in range(0, n, 2))
    
    # 分治，合並
    max_list = list(map(get_max, temp_list))
    
    # 遞歸（樹）
    solve(max_list)
        
        
# 分治法 版本二
def solve2(init_list):
    n = len(init_list)
    if n <= 2: # 若問題規模小於等於 2，解決
        return get_max(init_list)

    # 分解（子問題規模為 n/2）
    left_list, right_list = init_list[:n//2], init_list[n//2:]
    
    # 遞歸（樹），分治
    left_max, right_max = solve2(left_list), solve2(right_list)
    
    # 合並
    return get_max([left_max, right_max])


if __name__ == "__main__":
    # 測試數據
    test_list = [12,2,23,45,67,3,2,4,45,63,24,23]
    # 求最大值
    print(solve(test_list))  # 67
    print(solve2(test_list)) # 67

題目2. 給定一個順序表，判斷某個元素是否在其中。

# 子問題算法（子問題規模為 1）
def is_in_list(init_list, el):
    return [False, True][init_list[0] == el]


# 分治法
def solve(init_list, el):
    n = len(init_list)
    if n == 1: # 若問題規模等於 1，直接解決
        return is_in_list(init_list, el)
    
    # 分解（子問題規模為 n/2）
    left_list, right_list = init_list[:n//2], init_list[n//2:]
    
    # 遞歸（樹），分治，合並
    res =  solve(left_list, el) or solve(right_list, el)

    return res

if __name__ == "__main__":
    # 測試數據
    test_list = [12,2,23,45,67,3,2,4,45,63,24,23]
    # 查找
    print(solve2(test_list, 45)) # True
    print(solve2(test_list, 5))  # False

題目3. 找出一組序列中的第 k 小的元素，要求線性時間

# 划分（基於主元 pivot），注意：非就地划分
def partition(seq):
    pi = seq[0]                           # 挑選主元
    lo = [x for x in seq[1:] if x <= pi]  # 所有小的元素
    hi = [x for x in seq[1:] if x > pi]   # 所有大的元素
    return lo, pi, hi

# 查找第 k 小的元素
def select(seq, k):
    # 分解
    lo, pi, hi = partition(seq)
    
    m = len(lo)
    if m == k: 
        return pi                # 解決！
    elif m < k: 
        return select(hi, k-m-1) # 遞歸（樹），分治
    else:
        return select(lo, k)     # 遞歸（樹），分治
 
if __name__ == '__main__':
    seq = [3, 4, 1, 6, 3, 7, 9, 13, 93, 0, 100, 1, 2, 2, 3, 3, 2]
    print(select(seq, 3)) #2
    print(select(seq, 5)) #2

題目4. 快速排序

# 划分（基於主元 pivot），注意：非就地划分
def partition(seq):
    pi = seq[0]                           # 挑選主元
    lo = [x for x in seq[1:] if x <= pi]  # 所有小的元素
    hi = [x for x in seq[1:] if x > pi]   # 所有大的元素
    return lo, pi, hi


# 快速排序
def quicksort(seq):
    # 若問題規模小於等於1，解決
    if len(seq) <= 1: return seq
    
    # 分解
    lo, pi, hi = partition(seq)
    
    # 遞歸（樹），分治，合並
    return quicksort(lo) + [pi] + quicksort(hi)
 
seq = [7, 5, 0, 6, 3, 4, 1, 9, 8, 2]
print(quicksort(seq)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

題目5. 合並排序（二分排序）

# 合並排序
def mergesort(seq):
    # 分解（基於中點）
    mid = len(seq) // 2
    left_seq, right_seq = seq[:mid], seq[mid:]
    
    # 遞歸（樹），分治
    if len(left_seq) > 1: left_seq = mergesort(left_seq)
    if len(right_seq) > 1: right_seq = mergesort(right_seq)
    
    # 合並
    res = []
    while left_seq and right_seq:          # 只要兩者皆非空
        if left_seq[-1] >= right_seq[-1]:  # 兩者尾部較大者，彈出
            res.append(left_seq.pop())
        else: 
            res.append(right_seq.pop())
    res.reverse()                          # 倒序
    return (left_seq or right_seq) + res   # 前面加上剩下的非空的seq
    
    
seq = [7, 5, 0, 6, 3, 4, 1, 9, 8, 2]
print(mergesort(seq)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

題目6. 漢諾塔

# 漢諾塔
def move(n, a, buffer, c):
    if n == 1:
        print(a,"->",c)
        #return
    else:
        # 遞歸（線性）
        move(n-1, a, c, buffer)
        move(1, a, buffer, c) # 或者：print(a,"->",c)
        move(n-1, buffer, a, c)
    
move(3, "a", "b", "c")

問題7. 爬樓梯

假設你正在爬樓梯，需要n步你才能到達頂部。但每次你只能爬一步或者兩步，你能有多少種不同的方法爬到樓頂部？

# 爬樓梯
def climb(n=7):
    if n <= 2:
        return n
    return climb(n-1) + climb(n-2) # 等價於斐波那契數列！
    
print(climb(5)) # 8
print(climb(7)) # 21

問題8. 給定平面上n個點，找其中的一對點，使得在n個點的所有點對中，該點對的距離最小。（最近點對問題）

from math import sqrt

# 蠻力法
def solve(points):
    n = len(points)
    min_d = float("inf") # 最小距離：無窮大
    min_ps = None        # 最近點對
    for i in range(n-1):
        for j in range(i+1, n):
            d = sqrt((points[i][0] - points[j][0])**2 + (points[i][1] - points[j][1])**2) # 兩點距離
            if d < min_d:
                min_d = d                       # 修改最小距離
                min_ps = [points[i], points[j]] # 保存最近點對
    return min_ps
            


# 最接近點對（報錯！）
def nearest_dot(seq):
    # 注意：seq事先已對x坐標排序
    n = len(seq)
    if n <= 2: return seq # 若問題規模等於 2，直接解決
    
    # 分解（子問題規模n/2）
    
    left, right = seq[0:n//2], seq[n//2:]
    print(left, right)
    mid_x = (left[-1][0] + right[0][0])/2.0

    # 遞歸，分治
    lmin = (left, nearest_dot(left))[len(left) > 2]    # 左側最近點對
    rmin = (right, nearest_dot(right))[len(right) > 2] # 右側最近點對

    # 合並
    dis_l = (float("inf"), get_distance(lmin))[len(lmin) > 1]
    dis_r = (float("inf"), get_distance(rmin))[len(rmin) > 1]
    d = min(dis_l, dis_r)   # 最近點對距離

    # 處理中線附近的帶狀區域（近似蠻力）
    left = list(filter(lambda p:mid_x - p[0] <= d, left))   #中間線左側的距離<=d的點
    right = list(filter(lambda p:p[0] - mid_x <= d, right)) #中間線右側的距離<=d的點
    mid_min = []
    for p in left:
        for q in right:
            if abs(p[0]-q[0])<=d and abs(p[1]-q[1]) <= d:     #如果右側部分點在p點的(d,2d)之間
                td = get_distance((p,q))
                if td <= d: 
                    mid_min = [p,q]   # 記錄p，q點對
                    d = td            # 修改最小距離
                    
    if mid_min:
        return mid_min
    elif dis_l>dis_r:
        return rmin
    else:
        return lmin


# 兩點距離
def get_distance(min):
    return sqrt((min[0][0]-min[1][0])**2 + (min[0][1]-min[1][1])**2)

def divide_conquer(seq):
    seq.sort(key=lambda x:x[0])
    res = nearest_dot(seq)
    return res
    
    
# 測試
seq=[(0,1),(3,2),(4,3),(5,1),(1,2),(2,1),(6,2),(7,2),(8,3),(4,5),(9,0),(6,4)]
print(solve(seq)) # [(6, 2), (7, 2)]
#print(divide_conquer(seq)) # [(6, 2), (7, 2)]

問題8. 從數組 seq 中找出和為 s 的數值組合，有多少種可能

'''
求一個算法：N個數，用其中M個任意組合相加等於一個已知數X。得出這M個數是哪些數。

比如：
seq = [1, 2, 3, 4, 5, 6, 7, 8, 9]
s = 14 # 和

全部可能的數字組合有：
5+9, 6+8
1+4+9, 1+5+8, 1+6+7, 2+3+9, 2+4+8, 2+5+7, 3+4+7, 3+5+6
1+2+5+6, 1+3+4+6, 1+2+4+7, 1+2+3+8, 2+3+4+5
共計15種

http://club.excelhome.net/thread-443533-1-1.html

'''
# 版本一（純計數）
def find(seq, s):
    n = len(seq)
    if n==1:
        return [0, 1][seq[0]==s]
    
    if seq[0]==s:
        return 1 + find(seq[1:], s)
    else:
        return find(seq[1:], s-seq[0]) + find(seq[1:], s)
    
# 測試
seq = [1, 2, 3, 4, 5, 6, 7, 8, 9]
s = 14 # 和
print(find(seq, s)) # 15
    
seq = [11,23,6,31,8,9,15,20,24,14]
s = 40 # 和
print(find(seq, s)) #8


# 版本二 （打印） 
def find2(seq, s, tmp=''):
    if len(seq)==0:   # 終止條件
        return
    
    if seq[0] == s:               # 找到一種，則
        print(tmp + str(seq[0]))  # 打印
    
    find2(seq[1:], s, tmp)                              # 尾遞歸 ---不含 seq[0] 的情況
    find2(seq[1:], s-seq[0], str(seq[0]) + '+' + tmp)   # 尾遞歸 ---含 seq[0] 的情況

# 測試
seq = [1, 2, 3, 4, 5, 6, 7, 8, 9]
s = 14 # 和
find2(seq, s)
print()

seq = [11,23,6,31,8,9,15,20,24,14]
s = 40 # 和
find2(seq, s)