python实现动态规划中带权的活动安排问题

动态规划有两种实现思路，第一种是递归，第二种是自底向上，递归的复杂度比较高，所以我们实现的时候采取递归。

首先我们对带权的活动安排问题的进行描述，以及叙述该问题的解决方法。

问题：给定一组活动，活动的开始时间s，结束时间f，以及完成该活动可获得的收益w。如果si>=fj，则活动i和j是兼容的

目标：找到一个活动子集，使得子集中的活动相互兼容，并且收益最大。

分析：
def: OPT(j)为活动 {1，2，3…j} 可获得的最大收益
p(j): 在活动{1,2,3…j-1}中和 j 兼容的活动的最大下标
对于活动j，有两种处理方案，一种是选择该活动，一种是不选择该活动。选择该活动的的收益为wj+OPT(p(j))
不选择该活动的收益为OPT(j-1)

转移方程为：

代码实现为：

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 compute_pj(local_data, local_n):
    local_data[0].append(0)
    for i in range(1, local_n + 1):
        for j in range(i - 1, -1, -1):
            if local_data[i][0] >= local_data[j][1]:
                local_data[i].append(j)
                break
    return local_data


def 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, data = input_data()
    data = compute_pj(data, n)
    dp, select_flag = dynamic_programming(data, n)
    print(dp[n])
    while True:
        if n == 0:
            break
        if select_flag[n]:
            print(data[n])
            n = data[n][3]
        else:
            n = n - 1

测试数据及输出为

请输入活动的个数6
0 4 2
1 6 4
5 7 4
2 9 7
8 10 2
8 11 1
8
[8, 10, 2, 3]
[5, 7, 4, 1]
[0, 4, 2, 0]