带权重的活动安排问题，用归并算法对活动按照结束时间排序，用二分查找找pj

如有不懂，请看主页中的其他文章，学习归并算法和二分查找，以及带权重的活动安排问题，下面只贴代码

import numpy as np


# 第一行输入活动的个数，往后每行输入活动的开始时间，结束时间，以及权重
# 输出为选择的活动以及可以获得的最大效益

# 按照升序排列
def input_data():
    data_ = [[0, 0, 0]]
    n_ = int(input("请输入活动的个数"))
    for i in range(0, n_):
        temp = []
        s, f, w = map(int, input().split())
        temp.extend([s, f, w])
        data_.append(temp)
    return n_, data_


def merge(right_half_, left_half_):
    m_ = []
    r_ = l_ = 0
    while r_ < len(right_half_) and l_ < len(left_half_):
        # 因为如果两个数大小一样，归并排序不会改变两个数的先后位置，所以这个地方是< =
        if left_half_[l_][1] <= right_half_[r_][1]:
            m_.append(left_half_[l_])
            l_ += 1
        else:
            m_.append(right_half_[r_])
            r_ += 1
    if r_ == len(right_half_):
        for i in left_half_[l_:]:
            m_.append(i)
    else:
        for i in right_half_[r_:]:
            m_.append(i)
    return m_


def merge_sort(L):
    length = len(L)
    if length == 1:
        return L  # return多个变量不用()
    middle = length // 2
    left_half = merge_sort(L[:middle])
    right_half = merge_sort(L[middle:])
    return merge(right_half, left_half)


def compute_pj_with_binary_search(local_data, local_n):
    local_data[0].append(0)
    for i in range(0, local_n + 1):
        left = 0
        right = local_n - 1
        while True:
            middle = (left + right) // 2
            if left > right:
                break
            if (local_data[middle][1] <= local_data[i][0]) and (local_data[middle + 1][1] > local_data[i][0]):
                local_data[i].append(middle)
                break
            elif (local_data[middle][1] <= local_data[i][0]) and (local_data[middle + 1][1] <= local_data[i][0]):
                left = middle + 1
            else:  # 也就是local_data[middle][1] > local_data[i][0]的情况
                right = middle - 1
    return local_data


dynamic_programming(local_data, n_):
    opt = np.zeros([n_ + 1], dtype=int)
    select_flag_ = [0]
    for i in range(1, n_ + 1):
        if opt[i - 1] > opt[local_data[i][3]] + local_data[i][2]:  # 没有选job j,_select_flag[i]=0
            opt[i] = opt[i - 1]
            select_flag_.append(0)
        else:
            opt[i] = opt[local_data[i][3]] + local_data[i][2]
            select_flag_.append(1)
    return opt, select_flag_


if __name__ == '__main__':
    # n = 6
    # data = [[0, 0, 0], [0, 4, 2], [1, 6, 4], [5, 7, 4], [2, 9, 7], [8, 10, 2], [8, 11, 1]]
    n, data = input_data()
    sorted_data = merge_sort(data)
    data = compute_pj_with_binary_search(sorted_data, n)
    dp, select_flag = dynamic_programming(data, n)
    while True:
        if n == 0:
            break
        if select_flag[n]:
            print(data[n])
            n = data[n][3]
        else:
            n = n - 1