第十课 基础算法-贪心算法

python数据结构与算法基础 第十课

tags:

• python
• 路飞学院

categories:

• python
• 基础算法
• 贪心算法

第一节 贪心算法

1. 贪心算法的介绍

1. 贪心算法(又称贪婪算法)是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
2. 贪心算法并不保证会得到最优解，但是在某些问题上贪心算法的解就是最优解。要会判断一个问题能否用贪心算法来计算。

第二节 贪心算法实际问题-找零问题

1. 问题：假设商店老板需要找零n元钱，钱币的面额有: 100元、50元、20元、5元、1元，如何找零使得所需钱币的数量最少?
2. 贪心算法解决

# n是需要找给人的钱
t = [100, 50, 20, 5, 1]


def change(t, n):
    m = [0 for i in range(len(t))]
    for ind, money in enumerate(t):
        m[ind] = n // money
        # n是暂时没找开的钱
        n = n % money
    return m, n

print(change(t, 376))

第三节 贪心算法实际问题-背包问题

1. 问题：一个小偷在某个商店发现有n个商品,第i个商品价值Vi元，重Wi千克。他希望拿走的价值尽量高，但他的背包最多只能容纳W千克的东西。他应该拿走哪些商品?
   • 0-1背包:对于一个商品，小偷要么把它完整拿走，要么留下。不能只拿走部分，或把一个商品拿走多次。 (商品为金条)
   • 分数背包:对于一个商品，小偷可以拿走其中任意一部分。 (商品为金砂)
2. 背包问题解决-贪婪算法：

goods = [(60, 10),(100, 20),(120, 30)] # 每个商品元组表示(价格，重量)
goods.sort(key=lambda x:x[0]/x[1], reverse=True)
#print(goods)


def fraction_backpack(goods, w):
    m = [0 for i in range(len(goods))]
    total_prize = 0
    for ind, (money, weight) in enumerate(goods):
        if w >= weight:
            m[ind] = 1
            total_prize += money
            w -= weight
        else:
            m[ind] = w / weight
            w = 0
            total_prize += money * m[ind]
            break
    return m, total_prize


print(fraction_backpack(goods, 50))

第四节 贪心算法实际问题-拼接最大数字问题

1. 问题：有n个非负整数,将其按照字符串拼接的方式拼接为一个整数。如何拼接可以使得得到的整数最大?
2. 例: 32,94,128,1286,6,71可以拼接除的最大整数为94716321286128

from functools import cmp_to_key


li = [32, 94, 128, 1286, 6, 71]
def xy_cmp(x, y):
    if x + y > y + x:
        return -1
    elif x + y < y + x:
        return 1
    else:
        return 0


def number_join(li):
    # 把列表变为字符串列表
    li = list(map(str, li))
    print(li)
    li.sort(key=cmp_to_key(xy_cmp), reverse=False) # 默认就是False
    return "".join(li)

print(number_join(li))

第五节 贪心算法实际问题-活动选择问题问题

1. 假设有n个活动，这些活动要占用同一片场地，而场地在某时刻只能供一个活动使用。
2. 每个活动都有一个开始时间s和结束时间f: (题目中时间以整数表示)，表示活动在[si, f)区间占用场地。
3. 贪心结论:最先结束的活动一定是最优解的一部分。
4. 证明:假设a是所有活动中最先结束的活动，b是最优解中最先结束的活动。
   • 如果a=b,结论成立。
   • 如果a≠b，则b的结束时间一定晚于a的结束时间，则此时用a替换掉最优解中的b，a一定不与最优解中的其他活动时间重叠，因此替换后的解也是最优解。

activities = [(1, 4), (3, 5), (0, 6), (5, 7), (3, 9), (5, 9),(6, 10), (8, 11), (8, 12), (2, 14), (12, 16)]

#保证活动是按照结束时间排好序的
activities.sort(key=lambda x:x[1])
print(activities)


def activity_selection(a):
    res = [a[0]]
    for i in range(1, len(a)):
        # 当前活动的开始时间大于等于最后一个入选活动的结束时间。
        if a[i][0] >= res[-1][1]:
            res.append(a[i])
    return res


print(activity_selection(activities))