贪心算法

从活动选择问题引出贪心算法，然后说明贪心算法和动态规划的异同点，并说明贪心算法的求解步骤。

活动选择问题

【问题描述】假设有n个活动的组合 $S = { a_1,a_2, ...,a_n }$，这些活动使用同一个教室，同一时刻，教室只能举行一个活动，每个活动$a_i$都有一个开始时间$s_i$和一个结束时间$f_i$, 其中 $0 leq s_i  <  f_i $，若活动被选中，则发生在区间$[s_i, f_i)$内。 假如两个活动$a_i, a_j$,满足$[s_i, f_i)$和$[s_j, f_j)$不重叠，则它们是兼容的。 活动选择问题是，在这些活动当中选择一个最大的兼容活动集，它是活动的数量最多的集合。

动态规划思想求解

寻找这个问题的最优子结构，原问题是寻找事件S中的最多的活动，令$s_{min}$表示S中最早开始的活动, $f_{max}$是最晚结束的活动，原问题等价于选择时间$[s_{min}, f_{max}]$内的活动。 我们假设活动$a_i$是最优解当中的一个值，它的时间为$[s_i, f_i)$，那么当我们选择$a_i$以后，会出现两个子问题，选择时间$[s_{min}, s_i]$ 和时间$[f_i, f_{max}]$的活动。这样就可以建立递归方程，使用动态规划的思想来进行求解。而这样的$a_i$有n个，在这n个当中选择最大值。

递归的方法如下：

def activity_selection(s, f, start_time, end_time):
    """首先是做一个选择，并且假设该选择有最大值，在给选择下产生子问题"""
    if start_time == end_time:
        return 0

    max_value = 0
    for i in range(len(s)):
        current_start = s[i]
        current_end = f[i]

        if current_start >= start_time and current_end <= end_time:
            max_value = max(max_value, activity_selection(s, f, start_time, current_start)+activity_selection(s, f, current_end, end_time) + 1)
    return max_value

if __name__ == '__main__':
    # s是活动开始的时间，f是活动结束的时间，按照活动结束的时间进行了排序。
    s = [1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12, 14]
    f = [4, 5, 6, 7, 9, 9, 10, 11, 12, 14, 16, 20]   
    start_time = min(s)
    end_time = max(f)
    print(activity_selection(s, f, start_time, end_time))

动态规划方法如下：

def activity_selection(s, f, start_time, end_time):
    total_time = end_time - start_time + 1
    memorized = [[0 for i in range(total_time+1)] for i in range(total_time+1)]
    for i in range(1, total_time+1):
        for j in range(1, total_time+1):
            max_value = 0
            for index in range(len(s)):
                current_start = s[index] - start_time
                current_end = f[index] - start_time
                if current_start-start_time >= i and current_start-start_time <=j and current_end >=i and current_end <= j:
                    max_value =  max(max_value, memorized[i][current_start] + memorized[current_end][j] + 1)

            memorized[i][j] = max_value

    return memorized[1][-1]

贪心算法求解

在这个问题当中，我们在选择一个最优的活动的时候，有n种选择，这也是动态规划的特点，在发现最优子问题以后，将原问题分解为子问题以后，在诸多的子问题当中选择最优的那一个。 那么我们可不可以直接选择一个活动，那一个的结果就是最优的，这就引出了贪心算法。 在这个问题当中，我们每次选择一个结束时间最早的活动，并且证明一直做这样的选择能够让我们得到最优解，证明如下：

所以，当我们用贪心算法来求解的时候，只需要进行一个选择即可，

递归的贪心算法如下：

def recursive_activity_selector(s, f, k, n):
    activity = []

    # 活动m的开始时间应该小于活动k的结束时间
    m = k + 1
    while m <= n and s[m] < f[k]:
        m += 1

    if m <= n:
        return [[s[m],f[m]]]+ recursive_activity_selector(s, f, m, n)
    else:
        return activity

if __name__ == '__main__':
    s = [1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12, 14]
    f = [4, 5, 6, 7, 9, 9, 10, 11, 12, 14, 16, 20]
    # 插入0，表示前面有一个活动是从0开始，方便后续运算
    s.insert(0, 0)
    f.insert(0, 0)
    m = 0
    n = len(s)
    print(recursive_activity_selector(s, f, 0, n-1))

# result  [[1, 4], [5, 7], [8, 11], [12, 16]]

非递归版的贪心算法如下：

def greedy_activity_selector(s, f):
    """选择结束时间最早的活动"""
    activity = [[s[0], f[0]]]
    pre_activity = 0
    for index in range(1, len(s)):
        if s[index] >= f[pre_activity]:
            pre_activity = index
            activity.append([s[index], f[index]])
    return activity

if __name__ == '__main__':
    s = [1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12, 14]
    f = [4, 5, 6, 7, 9, 9, 10, 11, 12, 14, 16, 20]

    print(greedy_activity_selector(s, f))

贪心算法

贪心算法和动态规划问题一样，也需要最优子结构，原问题的最优解能够由子问题的最优解来构造。和动态规划不同的是，动态规划将原问题划分为子问题的时候涉及到诸多的选择，我们在这些选择当中选择一个最优的解，而贪心算法只涉及到一个选择：选择当前的最优解，不过贪心算法需要对这个选择进行证明，证明一直按照局部最优解进行选择，结果是全局最优解，这个性质叫做贪心选择性质。能用贪心算法解决的问题，都是可以用动态规划来解决。

贪心算法分为以下步骤：

1、将最优化问题转化为这样的形式：对其作出一次选择后，只剩下一个子问题需要求解。

2、证明作出贪心选择后，原问题总是存在最优解，即贪心算法是安全的。

3、证明作出贪心算法后，剩下的子问题满足性质：其最优解与贪心选择组合即可得到原问题的最优解，这样就得到了最优子结构。

0-1背包和分数背包问题

0-1背包问题的求解可以参考我的博客：背包问题 。 分数背包问题和0-1背包问题很像，但是物品的重量是可以分的，在选择拿物品的时候可以拿走一部分，而不必是整个物品。 分数背包问题可以用贪心算法来求解，但是0-1背包问题却不能用贪心算法来求解。分数背包问题的求解如下：

def fraction_package(w, v, m):
    """ 分数背包问题， 使用贪心算法来求解
    Args:
      w: weight
      v: value
      m: max weight of blg
    """
    current_weight = 0
    max_value = 0
    veight_per_weight = []
    for i in range(len(w)):
        veight_per_weight.append(v[i]/w[i])

    # 按照物品的单位价值，从大到小对index进行排序。
    value_per_weight_index = sorted(range(len(veight_per_weight)),
                                    key = lambda x:veight_per_weight[x],
                                    reverse=True)
    # 每次选择，总是选择单位价值最高的物品
    for index in value_per_weight_index:
        if current_weight < m:
            remainder_weight = m - current_weight
            if remainder_weight > w[index]:
                current_weight += w[index]
                max_value += v[index]
            else:
                current_weight += remainder_weight
                max_value += veight_per_weight[index] * remainder_weight
    return max_value

if __name__ == '__main__':
    w = [10, 20, 30]
    v = [60, 100, 120]
    m = 50
    print(fraction_package(w, v, m))

参考：

  算法导论16章