【编辑操刀】看不懂你打我，靠贪心算法出任CEO,迎娶白富美

1244220996

! }- g7 M* ^1 u  I) k# i/ e& V/ h今天，小明在街上看见一个在街上叹气的老头儿，老头儿为什么叹气的呢？因为老头儿他今儿有些犟犟的；
地上不是有排砖儿嘛，这路年久失修了砖儿碎得这一块那一块的。老头儿散着步呢，心血来潮想到着
+ Z. ~( v: u) X7 K- r7 P

老汉儿我心情好，看着碎路太磨脚。撸起袖子把砖掐，把这路给修一下。以什么为标准呢？以我的脚吧
我这脚儿有些大，看看鞋码四十八。一堆砖粉软趴趴，脚放在上边不够啊..

: h, M# K2 b* |; f$ F3 l8 k! `( l诶，有啦！

东边小碎儿西边半，凑在一起四十八，俺的大脚儿，有落啦！

- O/ b5 K  Q1 O1 }, \8 d" ]& l但老汉儿又头疼了。
7 z% o. h5 ~- Z# [

有点子是有点子，但没办法安排这砖儿啊。

- X# R# g( g9 O% w
想着想着，但也只能叹气了。

% ?& b. w4 ], d( _: I# S3 x小明刚被优化了，路过看见老头儿叹口气，就好奇上前询问。
“老汉儿，你头疼啥呢？”小明有些不解的问道。于是这老汉儿就跟小明说了他的问题。
8 k+ v& d( _% v; O, U( a2 C+ g小明一听这问题，拍了拍头皮
“诶？这不贪心算法嘛！”
, Y/ {9 W* c' K' t0 I2 o. n0 I
2 [4 a3 n2 p" @- J3 p! B( B; [
贪心算法（DJS）是一种巧妙的算法。作为一种决策类算法，他的核心就是“追求当下最优解以图全局最优解”
可以使用贪心算法的问题一般一般具备以下特点：

• 正时序（单向的）
• 问题可分解
• 单调倾向（涨，跌）
• 莫得太多选择
  2 p+ H% H; a! k' v) v7 g) D
  7 u, ?* A1 D( |

在贪心算法中有一个最好用的逻辑：满足容易满足的/对比容易比对的
% ~' O4 M/ H% W6 u* t# w) S

: K% X5 B9 T6 r+ y1 Q) c5 m
4 V  O+ m- y3 P) r! d8 i/ k% t4 H
“啊？（奶牛猫） 年轻人啊，你能不能说得再简单些哦，老头子我听不懂的哝,,”

“好吧，那我举点例子？”小明推了推油腻的黑框眼镜，继续讲道
( [. Q! h/ R0 S# {& E8 u
例如，有5个小朋友和一些饼干。这些小朋友高高矮矮胖胖瘦瘦都有的，所以想要狠狠地满足♡他们需要的饼干量也不同
其中，他们分别需要{5,3,2,5,7} 分量的饼干，但你只有{2,3,5,4,6,4,2}..
$ x- ^0 q% W/ c  Z# s' }
  P2 }/ [6 n; x/ h# e
“等等哦年轻人，为什么不把饼干掰开..”
; ]9 x) d  J! p“因为那是流心小饼干儿” 小明打断了老头，准备继续说道

6 Q% M9 Y4 C3 S9 U“那这样不会因为心的量不同而闹...”
% s  o- w+ J  F+ `' |" P3 e: d; d* n3 J老头没往下说了，主要是因为对方眼神的怨气也太重了
* y6 I  H  S* X# n/ Y- x7 R# D2 D
4 a& t* p- i+ c7 H
那么，你可以这样做：重新排序小朋友和砖..啊不，饼干
* z, b" z6 l1 T7 W# g

1. 小孩{2,3,5,5,7}
   $ I9 J0 }" U" @1 D1 J
2. 饼干{2,2,3,4,4,5,6}

复制代码

然后一把抓过最大只的小孩和最大的饼干
“怎么说？” "不中嘞哥哥，根本没办法吃饱呢...♡"  kid7，cookie6
3 T' v2 z2 }, ]* |# \; Z
好好好..然后拿了一个最小的饼干，然后小孩走了 kid7，cookie6+2

1. <font size="3">->
   8 W. Z2 Z$ q, u' g
2. 小孩{2,3,5,5}
   
3. 饼干{2,3,4,4,5}</font>

复制代码

然后是第二个， kid5，cookie5 pass
2 H7 c" c  y( O第三个，kid5，cookie4 re->cookie4+2 pass
: H1 `; }/ c7 z+ u% ^! _
+ T2 n# f& K4 u$ w第四个，kid3，cookie4 pass
( T. ~! V5 k7 I4 Q% y- y第五个，kid2，cookie3 pass

  s6 r4 i0 f& n& C5 _
( M" f0 b- b' ?. U当当，饼干分完啦
5 ~" o4 x4 L% u6 ]% b& c2 E上面这个，就是贪心算法的运行用例
8 r: t/ {/ F7 w( y


4 m5 q, N3 Q3 y. U* t6 {/ |( H
' Q9 }( n% h# z- y+ b
“这样啊，那年轻人啊，你有办法帮帮我解决砖块的问题嘛”
“嗨呀，这简单！”
" V7 {. _/ U9 Y  C; d小明从背包里拿出了一叠格子本和一只铅笔，写了起来

$ T+ L: r7 A9 H! |/ ~设大爷您的脚为 averageSize（均尺）
1 K3 j: K/ S1 f1 O% Q5 C6 y砖头组为          brickArr[brickArrSize]（砖头与砖头数量）
! n7 D# z+ Q) [" R  `7 O那么我们分解一下这个问题：
& |. s' U/ E: _/ W# R
设每一格路都需要尽量满足averageSize，则我们可以先把砖头大到小分解

1. sort(brickArr)
   % e: i, d) Y+ N/ r1 `  B* ^7 g6 K

复制代码

: t; @& a& F1 ?然后大砖头跟小砖头分开，再比较..
/ ~2 r9 e- @/ V0 `' ~0 V& Y

1. input averageSize    //均尺
   / J4 m) q) X. o; P) Z9 g" |
2. input allWay//所需的'整砖数'
   
3. input brickArr[brickArrSize]//砖头和砖头量,这里假设是用户写的值
   
4. int firstNode,lastNode;//指向最大和最小的指针
   
5. 
   
6. AnswerArr[allWay];   or  int * AnswerArr = (int*)malloc( sizeof(int) * allWay );
   # v8 B. ~$ O5 |/ B% ~
7.     //用于装砖块
   1 ~* R: P: H, M/ h0 e, ]- d  u
8. 
   2 I/ h2 y" G- X) ~
9. firstNode = 0;//这是一个很有用的初始值
   
10. lastNode = brickArrSize-1;//实标=字标-1 （第1位下标是0）
    
11. 
    
12. int i_tempPlus = 0;//声明赋值好习惯
    % Q; }4 T. @; Y
13. 
    
14. int i=0; //等一下要用的妙妙工具
    
15. 
    
16. for (i=0;i<allWay;i++) //路拼接，当前
    
17. {
    " j5 v( O' _! a+ ]* I5 T! [
18.     i_tempPlus = brickArr[lastNode--];
    ' Y# |3 w; H: y! x
19.    
    
20.     while(i_tempPlus<=averageSize && firstNode<=lastNode)  //位内循查，当前层1
    & g  x7 G2 w: a) E
21.     {
    9 ?. D- h1 _" Z( U& c7 E
22.         i_tempPlus += brkckArrSize[firstNode++];
    2 G- b/ U3 C, t2 u1 {, {( T
23. 
    , B, {% d; S' W6 y$ R  h( _
24.     }
    + ~; M5 Z4 s9 C" q9 T
25.    
    ' X& |, i! r( O$ \" ?
26.    
    
27.   
    
28.     if(i_tempPlus<=averageSize && firstNode>lastNode)//剩余无法满足
    " Q+ g( R8 a2 S+ g9 |
29.     {
    $ ]1 w# w& o; E2 p+ ]
30.         break;
    
31.     }
    ; D; _* c! h5 y8 Z' }  Z. b; I# h
32. }
    
33. 
    + V/ F$ ?& ^+ _2 a9 D
34. 
    
35. if(firstNode>lastNode && i_tempPlus<allWays)
      H$ B0 z& D& B
36. {
    7 q5 F; \  X9 T( ?8 q- d
37.     output "不行捏，只能满足 i_tempPlus个"
    ) q& e5 n) X. k$ V
38. 
    / M9 p  D/ b3 I/ V0 g3 P0 d1 M
39. }
    
40. else
      h1 \- P  X6 v/ T$ W
41. {
    
42.     /*nothing*/
    0 S: Z2 V1 `" o) {) ]# B0 M! D
43.     output"可以"
    
44.     output AnswerArr
    
45. 
    ) [( k9 c' `+ Y+ [  g
46. }
    $ m* ]. b( i8 v" t

复制代码

“这样，就可以得到你想要的答案啦”
- d! Y' m( S1 _

看着眼前的代码，大爷指了指其中的“AllWay”和“AllWays”
" t7 @  h$ e7 {4 F9 i“你这样会报错的。”

/ F  Q0 f: c2 [" l2 d2 [“大爷，你看得懂代码吗？”
“我是你学长。”


; ~4 n  y  v; v4 h6 v2 R1 B% L$ j
7 Y6 S0 d! s/ a3 f0 i------------------------
, ^" @, _1 A. F/ t6 a2 A
* `- i9 E- n( M: _可能还是有些迷糊，因为在文段内我使用了比较realCode的内容（防↓↑杠） 那么，我们再说一下


& H. {; ~, \7 _$ S作为一种非全局的策略算法，贪心是好用的也是需要慎用的。因为有时贪心反而会带来更糟糕的结果。这时候可以使用动态规划（dp）算法。 一个是快而美，另一个是繁杂而精密。
; D$ Y8 z: R$ a. |8 Z也许你会觉得，贪心算法是最简单的？不，贪心算法实际比动态规划更难 代码量与逻辑量看似更少，但实际是我们换了一个角度看的结果。例如砖块这题，如果让砖头的铺设多更多条件，贪心就无法满足了。 贪心解决的依旧是将问题分解后的子问题
9 w6 v( G+ P- y
1 n7 l1 k9 |2 B" q) s
" _$ q9 X5 G& d7 J* F
8 t1 |: S! i7 f/ l( \* C如果对更深层次的算法感兴趣且十分自信，可以看这本《算法导论》http://irjv2873gf.xyz:4765/thread-828327-1-1.html?x=2220329



7 l9 d% r& H5 V+ z( C4 \; c; N
9 e' Q8 Z" U1 H

  D1 G+ ^+ O/ C
/ f+ p' U1 }0 ]" m$ {-----编辑.navebayes




8 k  f6 L5 E' |% O8 p: D以下是原贴----


6 ^& H  K/ v/ a

  简单的编程算法——贪心算法，如何战胜先天围棋圣体柯洁？如何让一个普通人出任CEO,迎娶白富美？
   简单易懂，教你“贪心”。
   所谓贪心，就是一种在每一步选择中都采取在当前状态下最优的选择，从而希望结果最优的算法。
   以阿尔法狗战胜柯洁举例，人工智能？确实强大，但战胜人类围棋第一人，说到底最重要的就是它每一手都下在胜率最高的位置。强大的算力也只是分析出当前各个落子点的胜率而已。把这些胜率数据告诉我，我上我真行，普通人想独断围棋届万古，需要的也仅此而已（阿尔法狗用的动态规划，但在此例上我认为与贪心殊途同归，每一手都是胜率最高的选择，而这正是贪心算法的核心，所以化用了此例）
9 d: N$ n2 c2 j1 J# q: b+ b  |   贪心——局部最优解带来全局最优解。
  t" {5 O0 B7 x7 m; y! `4 `4 y, L7 F   每一手都落子胜率最高点=赢!
2 w  E- @- }4 O   这，就是贪心!
- Z3 @0 |7 p. {! r' F0 c1 x   而普通人要赢得人生，不就是这样吗？走好当下每一步，不看过去未来，就看现在，活在当下。以前是以前，现在是现在。你过去怎么摆烂都不重要了，读书的读好书，工作的认真工作，这就是普通人要赢的第一步，也是最重要的一步。
2 g$ m6 Q2 r: \3 Z* D  
   如果有人要说，现实哪是这么简单的？确实，就算你有大帝之资，运气不好出门被大卡车创死也有可能。但人潮人海中，我们能做的，最该做的，也仅此而已。难道因为不能长生不老，八荒六合唯我独尊就不认真生活了吗？赚无数财富成为世界首富固然另人欣喜，但你扪心自问，赢下一局游戏就不会令你感到快乐吗？接受自己的平凡，才是人生真正的开始。
   走好当下每一步，不一定能让你有所成，大概率也不能让你当上世界首富？但就像那个笑话:有个人天天去教堂虔诚向上帝祈祷中彩票大奖，终于上帝忍无可忍:你要中奖起码得先买张彩票吧？!  
   简单的“贪心”，只是一个算法，人生的程序跑起来肯定会有bug，但我们一个个修好这些bug，大概就能度过一个相对成功的人生了吧？
" \* l# Y; Q) ~$ H   与诸君共勉！

  P9 q: T5 z8 m% [! J以下是算法部分，可以略过。
+ |! ~1 M6 B0 C1 y& Z4 M7 o3 @算法说明:贪心算法（greedy algorithm，又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。 也就是说，不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解。 贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择。
# x& b/ Q3 e9 i% M
1 K7 ]5 l0 ~3 m7 ]贪心算法解题的一般步骤：
6 y% ~8 M% K% B7 I  h1. 建立数学模型来描述问题；
1 h5 r4 T- t; Y' [& {  I2. 把求解的问题分成若干个子问题；
* M# T- H3 V) N3 G  _" V1 I3 `0 d3. 对每一个子问题求解，得到子问题的局部最优解；
4. 把子问题的局部最优解合成原来问题的一个解。
# g- M8 _# q5 z* B$ h具体算法案例及伪代码:
找零钱问题：假设只有 1 分、 2 分、五分、 1 角、二角、 五角、 1元的硬币。在超市结账 时，如果 需要找零钱， 收银员希望将最少的硬币数找给顾客。那么，给定 需要找的零钱数目，如何求得最少的硬币数呢？
# -*- coding:utf-8 -*-
def main():
7 G$ L6 I  n. R/ a    d = [0.01,0.02,0.05,0.1,0.2,0.5,1.0] # 存储每种硬币面值
    d_num = [] # 存储每种硬币的数量
    s = 0
    # 拥有的零钱总和
    temp = input('请输入每种零钱的数量：')
" ]9 B5 `& {. j4 Z' Y5 B0 \    d_num0 = temp.split(" ")

    for i in range(0, len(d_num0)):
        d_num.append(int(d_num0))
        s += d * d_num # 计算出收银员拥有多少钱
2 X% I, p* n4 ~0 ^
    sum = float(input("请输入需要找的零钱:"))

7 S9 n7 G) _2 M    if sum > s:
: l$ E( s, R9 n& }, y- K2 d$ Q' C        # 当输入的总金额比收银员的总金额多时，无法进行找零
        print("数据有错")
        return 0
$ G" i5 C/ C' a$ @! W
    s = s - sum
    # 要想用的钱币数量最少，那么需要利用所有面值大的钱币，因此从数组的面值大的元素开始遍历
    i = 6
$ x1 k7 R4 f' e; J    while i >= 0:
! @) i$ M( [( N        if sum >= d:
" R4 U; {( ?' M1 ?7 b( X/ F, t            n = int(sum / d)
/ r& o; E, b. S7 j( P  X  f            if n >= d_num:
9 m. {# F0 P) [* C* x& H                n = d_num  # 更新n
3 }7 b! v5 ], B5 ^            sum -= n * d # 贪心的关键步骤，令sum动态的改变，
            print("用了%d个%f元硬币"%(n, d))
        i -= 1
1 l# B1 C/ y, p: G0 P
if __name__ == "__main__":
main()

a153588701

好好好，都能看懂是吧，感情老王就我一个铁废物，想起大学三个舍友，毕业一个马上就考上了公务员，两个家里直接给找好了工作，就我一个人傻逼呵呵的跟他们玩好几年，一毕业发现就我一个真废物

白驫

狐狸说葡萄，你看懂了没?
; x6 b" }' g1 t1 K9 [8 [, y! G
S（n）是一个集合，集合里有六个元素，
: X- L: u3 {6 A+ v; z第一个元素S（1）他的值是0.01
2 I) R7 q4 G/ a5 L5 ]& xS（1）他的值是0.02
. T5 B' P! j, y% d...
' t3 i0 m1 |. n0 {9 F; T2 O$ US（6）值为1
+ x" @9 f% [0 r/ n+ @% X8 z, m
$ w  V% a9 N" v# E1 z0 C2 SSu（n）一个集合，同样六个元素
- A3 ~) O8 e0 f  Z这个集合多少个个元素由玩家输入这里输入的就是收银员的币存。
( F6 [; B! M! ]$ k
, Y4 g* `! P( B7 B4 ]9 I# z' Q有了S（n）和Su（n）就算下总，这个总我们用d表示。这个总就是收银员现有的总钱

: g; L6 Y9 b* C! R7 Z/ }7 J然后又要你输入一个该扣除的钱数f

因为要尽量可能给出大面值硬币所以遍历从6开始递减是S（6）S（5）如此下去到S（1）
该扣除钱数f－（当前币值S（n）×当前币存的尽可能最大数）且f≠负数
每次钱扣除当前币值后余数去下一个币值再去减。
最后就是这样的，最后一堆找零。我有点忘了开头引用的是什么库。狐狸说葡萄，集合应该不是大学矩阵群环，应该不会也读不懂吧。当然其实还可以行列式一句搞定。

postqt

a153588701 发表于 2023-12-16 20:04
好好好，都能看懂是吧，感情老王就我一个铁废物，想起大学三个舍友，毕业一个马上就考上了公务员，两个家里 ...

亲兄弟我来晚了我大学同学也是一样的！三个室友！一个家里面给安排银行上班（虽然他自己不去跑了）一个家里面是厂里老员工然后厂老板强行让他回家了！还有一个听说家里面开厂的！毕业躺平摸鱼去了

Applcu

navebayes 发表于 2023-12-17 11:47
# l! K2 W7 p2 d3 [0 t@Applcu 可以看一下操刀后，这是我期望的水准来着。。

实话讲，第20到24行，有一些问题，部分特例是不太满足的，这个代码应对大多数这种拼砖问题都是可行的，但问题在于如果lastNode及前面lastNode-n个是一个接近于averageSize的值，同时其他值是趋近于二分之一averageSize的时候，并且需要的砖数小于n，这看起来就没这么合理了。理论上要找到这样的最优解，只能强行穷举所有可能，然后对比他们的距离（平方即可）再进行排列，取出前面误差最小的几个值组成数列，如果要求严格大于或小于averageSize，那么也可用一个if判断。当然计算量确实可怕。
/ t2 u# c( R% D. }. v: C

白驫

看到了，数组会用为什么多维数组的矩阵运算就不会呢？你是计算机的吗？数学模型很多需要计算机辅助的。

navebayes

这编辑器又发颠了？？

navebayes

白驫 发表于 2023-12-16 18:03
% ~9 Y9 o- ~9 O3 z看到了，数组会用为什么多维数组的矩阵运算就不会呢？你是计算机的吗？数学模型很多需要计算机辅助的。 ...

$ u/ ]  k7 y  I/ R+ C因为这里在讲贪心算法
2 A' U0 i8 H) d. X

navebayes

a153588701 发表于 2023-12-16 20:04
好好好，都能看懂是吧，感情老王就我一个铁废物，想起大学三个舍友，毕业一个马上就考上了公务员，两个家里 ...

  l. a: ?+ s1 v1 o$ g& \' n原来的评论有很多不懂的，但评论不知道为什么不见了。术业有专攻很正常

昔有佳人公孙氏

贪心算法很强大。很多计算机相关算法都有他的影子。无论是银行家算法还是哲学家吃饭
' O4 n. |- Q5 j; l- a" K唉 算了 我还是复习去吧 越说心里越没底 还好这破玩意初试不考

navebayes

昔有佳人公孙氏 发表于 2023-12-16 22:32
贪心算法很强大。很多计算机相关算法都有他的影子。无论是银行家算法还是哲学家吃饭
' g! ?+ w' }$ ~; c# ~2 E唉 算了 我还是复习去 ...

确实，虽然写着挺简单但实际比动态规划更难，主要是靠拆分问题的能力

navebayes

@Applcu 可以看一下操刀后，这是我期望的水准来着。。

Applcu

navebayes 发表于 2023-12-17 11:47
@Applcu 可以看一下操刀后，这是我期望的水准来着。。

& \+ V5 `( ], }/ X5 h2 g你们再这么搞，过两天这论坛成了计算机学生的耶路撒冷...黄网界的力扣
; y; n) c- ]; u2 h/ Z3 Q

Applcu

navebayes 发表于 2023-12-17 11:47
@Applcu 可以看一下操刀后，这是我期望的水准来着。。

" ]- x0 K8 u7 O# N* b6 V3 M; M: b8 J我想到了之前大一做的一个题，算很经典的题目，就是小青蛙跳台阶，如果这个小青蛙一次只能跳1或3个台阶，请列举小青蛙跳n个台阶的跳法种数，异曲同工之处，当然也有一些不同点

navebayes

* j( \) [3 P7 \

Applcu 发表于 2023-12-17 13:25
# _' T# Z) ^: h$ b# o实话讲，第20到24行，有一些问题，部分特例是不太满足的，这个代码应对大多数这种拼砖问题都是可行的，但 ...

; n: w6 w! A  g2 Y是的，这代码如果遇到案例值相差极大时难以满足，如果要解决的话需要改一下标记结构，摸了 用这个编辑器写代码太折磨了。。
% Q1 p) t, e0 n: y6 ]* w/ N虽然在实际运行环境会使用低精度离散哨兵（lowDispFlag）作为辅助维护器
6 H* k" S7 H8 j% G( Q4 K大致可以理解为把尺寸分割为不同阶然后用安插哨兵子并且用散列储存，这样做可以保持在nlog+C

navebayes

Applcu 发表于 2023-12-17 13:25
实话讲，第20到24行，有一些问题，部分特例是不太满足的，这个代码应对大多数这种拼砖问题都是可行的，但 ...

# i  M7 x# U) y3 C/ n5 ]- S- l8 S哦不是二巡，是需要改变标记结构

navebayes

Applcu 发表于 2023-12-17 13:32
3 \/ g8 i3 K$ u, Z7 P我想到了之前大一做的一个题，算很经典的题目，就是小青蛙跳台阶，如果这个小青蛙一次只能跳1或3个台阶， ...

/ `% Y4 l5 T1 R/ I/ H那个是dp题

Applcu

navebayes 发表于 2023-12-17 13:39
& i1 r- K4 \5 D) V9 e6 R4 H7 I是的，这代码如果遇到案例值相差极大时难以满足，如果要解决的话可以进行低位二巡；不过还要多写一个循环 ...

太顶了你是真正的大佬
$ N8 X$ \2 B# j, Q8 S1 B0 V5 P! y

navebayes

Applcu 发表于 2023-12-17 13:50
/ a$ ?5 E3 X$ E9 _太顶了你是真正的大佬

不至于不至于不至于(=ﾟДﾟ=)   只是去年的时候玩过一些算法 所以用自己知道的说出这些而已...  其实算法思路都差不多的，理解为数学题那样的形式，然后用函数解题就行了

navebayes

: L1 B  C# U- M! u9 z3 K: B- ~

Applcu 发表于 2023-12-17 13:50
太顶了你是真正的大佬

( ]' l" U  Q$ E, O9 e% k而且你也很不错啊，第一眼就看出问题在哪里了。如果你感兴趣的话，也可以写一些帖子，这样就有理由给你打赏了(´,,•ω•,,｀)
' t& T" u) t! v9 \5 C  j1 o这里终究是论坛，不是我的博客，内容都是得靠大家的..

Applcu

navebayes 发表于 2023-12-17 14:04
* A7 m8 ~# ]( g! c' F而且你也很不错啊，第一眼就看出问题在哪里了。如果你感兴趣的话，也可以写一些帖子，这样就有理由给你打 ...

& v! I% O4 E" y7 t  X好的好的，我尽量写帖子哦