蓝桥杯-贪心算法_蓝桥杯贪心算法

写在前面：贪心算法是算法中最简单的算法，最好理解，最好写代码的算法，通过这次的学习，熟练掌握了这个算法，接下来要往更加复杂的算法学，提高能力
​
贪心算法（Greedy algorithm），又称贪婪算法。是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而使得问题得到全局最优解。

​ 要求:所有的选择是无后效性的，即当前所作的选择不影响后续选择对于结果的影响

​ 适用范围：该问题的每一步选择都在选择最优的情况下能够导致最终问题的答案也是最优

例题

1、找零问题

问题描述

假设商店老板需要找零 n 元钱，钱币的面额有：100 元、50 元、20 元、5 元、1 元、如何找零使得所需钱币的数量最少？

注意：n 可能为 0，也能为几百元

输入:

	在第一行给出测试例个数 N，代表需要找零的钱数。
输入样例：
	365

输出
　　有 5 行输出数据，每一行输出数据输出找零的金额与数量，详情看样例。
输出样例：
    100:3
    50:1
    20:0
    5:3
    1:0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

解决代码

# 请在此输入您的代码
L = [100, 50, 20, 5, 1]
Ans = [0 for _ in range(5)]
N = int(input())
for i in range(len(L)):
  Ans[i] = N // L[i]
  N %= L[i]
for i in range(5):
  print(L[i],end='')
  print(":",end='')
  print(Ans[i])
#print(L[i],":",Ans[i])

1
2
3
4
5
6
7
8
9
10
11
12
13

2、小B的宿舍

问题描述

小B的宿舍楼沿着走廊南北向的两边各有 200200 个房间，如下所示：

[房间1][房间3][房间5][房间7][房间9 ]...[房间399]
----------------------------------------------
                   走廊
----------------------------------------------
[房间2][房间4][房间6][房间8][房间10]...[房间400]

最近，由于转专业和专业分流的原因，宿舍将迎来新的调整，以便组成新的班级后方便管理。

但是由于走廊狭窄，走廊里只能通过两个搬运的物品（可以同向也可以反向），因此必须指定高效的搬运计划。

老师给了每位同学下达了以下要求，让同学们体现收拾好行李，然后给每位同学 1010 分钟的时间搬运。

当从房间i搬运行李到j时，i与j之间的走廊都会被占用，但是可以容纳两个不同同学同时搬运。所以，10分钟之内同一段走廊最多两个人同时搬运，不重叠的走廊也可以同时搬运。

小B的老师是个数学老师，经过运筹学一通计算他得到了最优的搬运计划。

虽然计划不唯一，但是最优值唯一，请问这个最短时间是多少？

输入描述
输入数据有T组测试例，在第一行给出测试例个数 T。

每个测试例的第一行是一个整数 N(1≤N≤200)，表示要搬运行李的人数。

接下来 N行，每行两个正整数 s和 t，表示一个人，要将行李是从房间 s移到到房间t。

输出描述
每组输入都有一行输出数据，为一整数 Time，表示完成任务所花费的最小时间。


输入
3
4
10 20
30 40
50 60
70 80
2
1 3
2 200
3
10 100
20 80
30 50

输出
10
10
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

解决代码

T = int(input())
for i in range(T):
  Ans = [0 for i in range(401)]
  N = int(input())
  for i in range(N):
    s, t = map(int, input().split())
    for i in range(s, t + 1):
      Ans[i] += 1
  ans = max(Ans)
'''
要注意最后结果算的时候，
当一个宿舍前经过的次数为奇数的时候，整除完要加一，
为偶数的时候要整除，不整除会出现小数（float类型），导致提交会失败
'''
  if (ans % 2 == 0):
    print((ans // 2) *10)
  else:
    print((ans // 2 + 1) * 10)
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3、贪心的自助餐

问题描述

小B同学想去吃自助餐，但是他是那种比较节俭的的人，既不想浪费食物，又想尽可能吃的贵一点，他于是私下里做了调查。

小蓝餐厅的自助餐有n种食材，每种食材都有它的价格。

而且也能估计出每一份的重量，所以他列了一个表格：

菜品	价格（元）	重量（g）
红烧牛肉	30	300
油闷大虾	8	5
四喜丸子	4	8
三文鱼		 5	3
排骨		 18	200
麻辣兔头	20	120
高汤海参	40	70
扇贝粉丝	8	32
牛排		 79	240
小B的饭量C(g)，他想知道在不超过饭量的情况下他最多能吃多少钱的菜品。

请你设计一个程序帮助小B计算他的最多吃了多少钱。（假设自助餐厅的菜品供应同样的菜品每个人只能取一份。）

输入描述
第一行输入两个整数 n,C (0≤n≤10^3,0≤C≤10^4），其中n为菜品数量，C 为小B的肚子容量。

接下来n行每行输入两个数 v[i],w[i],v[i] 是第i个菜品的价值，w[i]表示第i个菜品的重量（0≤v[i],w[i]≤10^4）。

输出描述
输出一行数据，表示最大的价值，保留小数点后三位数。


输入

20 1000
1 22
2 43
123 214
12 2
123 432
21 223
22 16
77 49
34 78
34 9
43 677
21 34
23 23
12 56
332 56
21 99
123 545
389 33
12 999
23 88

输出

1204.114
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

解决代码

# 请在此输入您的代码
n , C = map(int, input().split())
v = [0 for i in range(n)]
w = [0 for i in range(n)]
ave = [0 for i in range(n)]
for i in range(n):
  v[i], w[i] = map(int, input().split())
  ave[i] = v[i] / w[i]
print(ave)
if(sum(w) <= C):
  print("{:.3f}".format(sum(v)))
else:
  V = 0
  W = 0
  for i in range(n):
    Max = max(ave)
    #print(Max)
    Index = ave.index(Max)
    #print(Index)
    if(W + w[Index] < C):
      V += v[Index]
      W += w[Index]
##      v.remove(v[Index])
##      w.remove(w[Index])
##      ave.remove(ave[Index])
      del v[Index]
      del w[Index]
      del ave[Index]
      #print(W)
      #print("aver is  :", Max)
    else:
      #print("C - W :",C - W)
      V += (C - W) * Max
      break
  print("%.3f"%V)
  #print("{:.3f}".format(V))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

这个题一直调试了很久，原因在于没有用好数组删除元素操作，而我最开始用的是第一种，然后提供的原始数据中有重复元素，这里就出现了remove删除第一个匹配元素的做法，导致结果一直不对，记录一下数组的删除操作

数组删除元素有四种方式

• 1.删除第一个匹配数据：

>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]
1
2
3
4

• 2.根据index删除数据：

>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]
1
2
3
4

• 3.根据index删除数据并返回该数据：

>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]
1
2
3
4
5

• 4.在循环中删除元素：

a = ["a", "b", "c", "d", "e"]
for item in a[:]:
    print item
    if item == "b":
        a.remove(item)
1
2
3
4
5

再贴一个官方的做法

class Food:

   def __init__(self, w, v, aver):
       self.w = w
       self.v = v
       self.aver = aver

   def __repr__(self):
       # print(11)
       return repr((self.w, self.v, self.aver))


# def cmp(foodA: Food, foodB: Food):
#     if foodA.aver >= foodB.aver:
#         return True
#
#     else:
#         return False
#
#
# 当然 python 的 sort 是不需要写 cmp 函数的，这里我们使用 sorted 就不用 cmp 函数了

if __name__ == '__main__':

   foods = []

   C = 0.0

   Value = 0.0

   n, C = map(int, input().split())

   for i in range(n):
       food = Food(0, 0, 0)
       food.v, food.w = map(int, input().split())

       food.aver = food.v / food.w

       foods.append(food)

       # print(food.aver)
       # print(foods)

   # 性价比排序
   foods.sort(key=lambda f: f.aver, reverse=True)
   # for i in range(n):
   #     print(foods[i].aver)

   sum=0

   for i in range(n):
       sum+= foods[i].w

   # 当背包（肚子）能装下所有物品（菜）时，直接输出所有的物品（菜品）价值之和
   if sum<=C :

       for i in range(n):

           Value+=foods[i].v;

       print(Value)

   # 当背包（肚子）不能装下所有物品时应该由性价比的顺序，选择装入的物品
   else:

       for i in range(n):
           print(Value)
           if foods[i].w<=C:
               Value=Value+foods[i].v
               C=C-foods[i].w
               print("aver is ",foods[i].aver)
              
           #     直接将剩余的C加入即可
           else:
               print("C is ",C)
               Value+=C*foods[i].aver
               
               C=0

           if C==0:
               break

       print("%.3f" % Value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84