【项目总结】2018年全国大学生数学建模大赛B题简要分析（附代码）

杨利霞

【项目总结】2018年全国大学生数学建模大赛B题简要分析（附代码）
" c  Q: G; G" H& X, t- O/ E
4 Z/ X; e5 R) K; V' x今天早上跟学姐室友去复旦把论文答辩做掉了，虽然整个项目基本上是我承担了主要的思路与代码部分，但是今天答辩我跟室友竟然连一句有用的话都没说出来，全场都靠学姐开场流畅地引入，临场随机应变，从而得以与答辩教授欢聚喜散。主要原因是教授竟然准确地问到了我代码里一个细节却相当致命的问题（是一个随机初始化问题，我下面代码部分会详细提到），正好学姐室友都不是特别熟悉我的随机初始化方法，我又不能当场跟他们两个解释这个随机初始化的问题。我差点当场就要以“这样随机初始化能够减少代码量”这种蹩脚的理由跟教授争辩了。好在姜还是老的辣，辩论队队长出身的学姐一顿 Speech Art 操作成功忽悠掉了两位教授，最终两位答辩教授还是认可了我们的模拟仿真方法[捂脸]。事后细想以后我成功也好，失败也罢，恐怕也是成也言语，败也言语。也许我确实能够成为一个有能力的人，但是说话艺术确实是一门很大的学问。不过看我运气一直这么差，大概率还是凡人一个落入俗套吧[摊手]。
! B' o6 w( P! y* B4 l6 l
言归正传，本文主要介绍我们小组解决2018年全国大学生B题的思路分析，不代表标准答案。当然我还是有自知之明，本身水平不是很高，再加上三天时间限制，自己做出来的模型以及算法肯定是比较差的。这里仅仅从我个人的思考角度出发写一些参考思路作为分享讨论，希望各位读者朋友轻喷。

问题分析
+ }' H* e2 k" J
% |- s8 {- f( t  M今年的B题确实与往年有很大的不同。往年的数学建模问题往往具有比较好的开放性，问题解决存在较大的建模空间。今年的B题的题干本身就几乎是一个明确的模型（8台CNC+1台RGV+CNC定址），加上第二道任务要求我们根据给定三组数据完成八小时内的RGV详细调度方案，并写入四张Excel表格，给人的感觉就是要求我们去完成一道填空题，然后附带写一篇论文[尴尬]。

7 h2 h8 m) _8 f- \为了方便各位读者对赛题的阅读，这里给出链接：https://download.csdn.net/download/cy19980216/10708725

. y0 S1 Y2 n0 Q问题一共有四种不同的情况：一道工序无故障，一道工序有故障，两道工序无故障，两道工序有故障。

一道工序无故障

第一种情况是最简单的，直观上直接不停地1234567812345678……按顺序上料差不多就是最优了。但严谨地来说，虽然题目中给的三组数据确实都是用这种最幼稚的策略能够达到最优，但是如果对于一般的情况而言，比如最极端的情况下，RGV移动时间无穷大，那RGV显然就只会不停地在121212121212……这样原地上下料了。

然而我们发现无论参数怎么变化，最终RGV给CNC上下料的过程始终是一个周期性过程。当然这个似乎很“显然”的事实却是相当难以通过数学严格证明的（参数已知的情况下一般比较容易证明，但是所有的参数都是未知的情况下是很难严格说明的）。我赛后也仔细的思考过，但是也没有得出很漂亮的证明。我最终仅仅是针对给定的三组数据使用了遗传算法对RGV前17次上下料（17次是考虑从初始状态开始循环两圈的最短路径）的最优路径进行了搜索，并且利用穷举证明了这是前17步最优的上下料次序。之后基本上就是不断地循环。
8 V, G, I. P- K  _
这里的模拟退火遗传算法比较鸡肋，所以我不详细说明，在第三种情况我会详细说明模拟退火遗传算法的原理。
6 J, W( O( u' u  k( g! W
以下给出第一种情况的模拟退火遗传算法算法以及对应的穷举最优证明 ↓↓↓
+ T  S4 d: u. E& e$ w3 H6 L# -*- coding:UTF-8 -*-
"""
" ?$ m# U/ f) Z" Q' t7 y$ d) P9 G        作者：囚生CY
        平台：CSDN
5 I' x$ x. U0 x. N  ~        时间：2018/10/09
        转载请注明原作者
        创作不易，仅供分享
; f/ ^1 S, j; D, Y8 R"""
6 M$ n& G+ ?3 ?7 f
; d4 v0 |! D8 X! B" t( m6 oimport math
import random
( [; k: O+ Q0 \import itertools

6 w, {3 X! ^' x  i""" 选取一组数据 """
. M: \. F3 ~# u7 hT = 580
d1 = 23
d2 = 41
# K/ {" T& F" @# ^9 x' pd3 = 59
4 T% O6 w# _9 G1 W7 v3 \2 fTe = 35
* y0 ~/ }% T. W% y8 L( ^4 G/ BTo = 30
& u1 i$ w- d  H. |) mTc = 30

CNCT = [To,Te,To,Te,To,Te,To,Te]                                                                                 # CNC上下料时间
5 C1 [3 Y" n7 o: \+ l
" x/ h, F% m1 X  R% O# `N = 50
L = 17
. a2 j: K4 B+ {/ J
4 f* E& \5 Z; K+ ]# U7 d( F& BvarP = 0.1
croP = 0.6

5 A* Z6 ?0 o; \) L' [& ~croL = 4
  N  S4 g+ @1 D3 a2 re = 0.99

5 q& k# R& Q( n+ \+ }/ C- e+ n3 xtm = [
# [9 i( |' @* n6 R2 I8 v/ T        [0,0,d1,d1,d2,d2,d3,d3],
% m3 Z# a! J2 N: H+ f# N4 F        [0,0,d1,d1,d2,d2,d3,d3],
        [d1,d1,0,0,d1,d1,d2,d2],
7 ^7 ^: `8 n. D% g4 ~        [d1,d1,0,0,d1,d1,d2,d2],
3 b! t. Q0 E6 D7 u4 d* h        [d2,d2,d1,d1,0,0,d1,d1],
( R' k+ s+ W( |: X8 V( r! v- l        [d2,d2,d1,d1,0,0,d1,d1],
        [d3,d3,d2,d2,d1,d1,0,0],
4 j& d6 v. A7 p8 m0 R8 [6 |& b9 b        [d3,d3,d2,d2,d1,d1,0,0],
# O4 w; h3 t, u/ p, X% }]
$ }& `3 ]2 `) U" i0 K* R
* b( m1 ^& a& ^/ Idef update_state(state,t):
/ G/ |% K  d7 l/ Y9 f" V        length = len(state)
        for i in range(length):
; h% H1 Z4 P  U' E                if state < t:
# @6 q& b: K0 {                        state = 0
$ T! @- ^, B, U0 O# y4 a5 D2 \0 I                else:
                        state -= t
0 j  r; s7 u! a# Z; k" P        return state

def time_calc(seq):
        state = [0 for i in range(8)]                                                                                   # 记录CNC状态
        isEmpty = [1 for i in range(8)]                                                                                 # CNC是否为空？
        currP = 0
        total = 0
        length = len(seq)
! Z- G9 u6 X2 F! h( A$ M0 ~' o        for No in seq:
/ U) E- Y$ `7 V# a) J                nextP = No
                t = tm[currP][nextP]
                total += t                                                                                                                 # rgv移动
                state = update_state(state,t)                                                                         # 更新state
                if state[No]==0:                                                                                                 # 表明CNC等待
                        if isEmpty[No]:                                                                                                 # 当前CNC空
- T/ a! U2 l+ u# _( n1 M0 T                                t = CNCT[No]
, {& L  T9 c% I+ Y/ D, R6 U! m. y                                isEmpty[No] = 0
4 c2 ^( r5 h* x: K  k                        else:
3 T& C9 c/ ~1 r7 u  e5 u2 ~/ T                                t = CNCT[No]+Tc
                        total += t
+ N, c$ }: H0 \: o                        state = update_state(state,t)
                        state[No] = T
$ t6 m! \: d/ |& M                else:                                                                                                                         # 当前CNC忙
                        total += state[No]                                                                                         # 先等当前CNC结束
                        state = update_state(state,state[No])                                                 
                        t = CNCT[No]+Tc
                        total += t
                        state = update_state(state,t)
                        state[No] = T
                currP = No
        total += tm[currP][0]
. y. ^/ I. g" z4 [1 \' a6 A/ F        return total

def init_prob(sample):
        prob = []
$ q8 {- B; T& S0 A+ O7 w. {        for seq in sample:
                prob.append(time_calc(seq))
$ L+ v: q" W8 u* F        maxi = max(prob)
        prob = [maxi-prob+1 for i in range(N)]
4 C8 B- I, N2 I4 F% |* D        temp = 0
        for p in prob:
                temp += p
        prob = [prob/temp for i in range(N)]
        for i in range(1,len(prob)):
                prob += prob[i-1]
        prob[-1] = 1                                                                                                                 # 精度有时候很出问题
        return prob

def minT_calc(sample):
# {+ u4 g( d6 r5 X; v' t        minT = time_calc(sample[0])
( O6 A1 H- I/ i" E+ `        index = 0
$ ~4 d" z! t! Y, L        for i in range(1,len(sample)):
                t = time_calc(sample)
                if t < minT:
                        index = i
: g4 K* z) y6 q$ \1 ?                        minT = t
9 J3 _2 U4 |+ a4 c. M  {( ^5 Y( ]        return minT,index
# B) ]5 H7 e0 e! L" o! d       
def init():
        sample = []
        for i in range(N):
% S  h9 m3 u9 i                sample.append([])
                for j in range(L):
# C$ @- l# Q9 [/ V5 B                        sample[-1].append(random.randint(0,7))
        return sample

def select(sample,prob):                                                                                                 # 选择
; b6 a! @+ g! t& s, t        sampleEX = []
3 M7 X, k. B4 e7 d        for i in range(N):                                                                                                         # 取出N个样本
0 [: q, M( p4 P9 C3 p) z( {                rand = random.random()
4 P% t: e5 l* t+ ^, S% ]                for j in range(len(prob)):
$ e7 |! E( a4 \" N+ R+ o3 C                        if rand<=prob[j]:
% x: C& g% v4 ?. H; _7 n" n( x                                sampleEX.append(sample[j])
6 n& G" b) l8 G% [$ x  k                                break
        return sampleEX

  J: C3 d- H: _# Y4 |0 E: M# Wdef cross(sample,i):                                                                                                         # 交叉
        for i in range(len(sample)-1):
+ a# v& w% b/ K0 M8 q( U                for j in range(i,len(sample)):
                        rand = random.random()
                        if rand<=croP*(e**i):                                                                                 # 执行交叉
                                loc = random.randint(0,L-croL-1)
1 r2 @/ ^# z* ^2 a1 U' A( y* D2 `' W) u+ Q                                temp1 = sample[loc:loc+croL]
9 t$ p% @9 X; q$ \* U! [' Z                                temp2 = sample[j][loc:loc+croL]
                                for k in range(loc,loc+croL):
! p7 ^' k& v8 t* A. w% }' y                                        sample[k] = temp2[k-loc]
+ {2 I. @  d3 t9 T/ M. Q                                        sample[j][k] = temp1[k-loc]
        return sample
               
def variance(sample,i):                                                                                                         # 变异算子                                                                                 
        for i in range(len(sample)):
9 n& O1 s+ f9 ^0 b4 N4 h                rand = random.random()
; T9 Q) T4 C& F/ ]+ @- a# I" \                if rand<varP*(e**i):
                        rand1 = random.randint(0,L-1)
                        rand2 = random.randint(0,L-1)
                        temp = sample[rand1]
                        sample[rand1] = sample[rand2]
                        sample[rand2] = temp
        return sample
       
def main():
        sample = init()
( r. I* G3 @, n4 \7 Z        mini,index = minT_calc(sample)
        best = sample[index][:]
        print(best)
( h$ {/ Z* X5 e' Y. z7 s8 L        for i in range(10000):
. u' r/ u, \8 Y+ Q                print(i,'\t',minT_calc(sample),end="\t")
                prob = init_prob(sample)
& C7 ]+ z4 Q$ x( z, `                sample = select(sample,prob)
                sample = cross(sample,i)
! t1 r4 q0 N! {# E) m! _                sample = variance(sample,i)
                mi,index = minT_calc(sample)
; [$ t' i& Z* ]& W. p4 s6 m! j                if mi>mini and random.random()<e**i:                                                         # 精英保留策略
                        rand = random.randint(0,N-1)
; R  g! C& C2 b, l4 g                        sample[rand] = best[:]
6 X/ e5 N$ n- }" t& ?                mini,index = minT_calc(sample)
                best = sample[index][:]
% m& y+ H5 ]6 o' s1 }                print(best)
        print(sample)

if __name__ == "__main__":
3 C1 j# H+ o( V' H/ |) P, p        main1()
, w) Q$ k5 A/ _3 N- \) [5 W        """ 穷举搜索验证 """
        a = list(itertools.permutations([1,2,3,4,5,6,7],7))
        ts = []
$ ?0 ^, b7 z% f+ z. R        first = [0,1,2,3,4,5,6,7,0]
        for i in a:
8 A; |0 n& W+ E, e" d( _                temp = first+list(i)
2 z% [; P9 |1 g! b' p                temp.append(0)
                t = time_calc(temp)
; O6 E% C  x1 {; b( Z' I+ p& ?                ts.append(t)
        print(min(ts))       
) I7 {1 \% J! i* o" T5 R8 G        print(time_calc([0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7,0]))
       

一道工序有故障
0 K. T# F& b& M. R1 `) P
3 b: v  g+ j) t( F( g) q这部分是学姐做的，学姐用了偏数学的思考方式，仍然从循环的角度去考虑，主要考虑故障发生是否会影响当前循环，是否需要建立新的循环。因此就没有写代码处理问题了。具体的思路我确实不是很能讲清楚。但是这里面有一个非常大的问题，就是如果出现多台CNC同时发生故障怎么办。关于多台机器同时发生故障的概率，我们通过估算认为以给定的三组数据8小时内会出现这种特殊情况的可能性大约为30%。这个问题是我无法很好严格处理的（当然如果用贪心算法也就没这么多事了）。

  S. u% Y3 G! P) J两道工序无故障 & 两道工序有故障
  r/ J/ {1 _5 [2 L, A
这两个部分都是我来处理的，因为使用的方法大致相同，就并在一起说了。
4 [; }6 k1 w# n% ?' J
两道工序与一道工序最大的区别在于三点：

, r( Q: s6 v; ~$ N1、开始要处理CNC任务分配：分配给第一道工序几台CNC，分配给第二道工序几台CNC？具体怎么布局？
4 |! X( l) r5 e
& B  A7 W- _; |1 A) L; R2、加工过程可能仍然是一个循环，但是这个循环将可能会非常的庞大以至于不可能直观的看出来。
5 z4 I) m$ T' y7 H  w
3、两道工序的分配已经是一个严格的NP难问题了（即理论上无法在多项式时间内求得最优解）。

第一点我的想法很单纯——穷举，没错，就是穷举，除了显然不合适的分配方案外，其他方案都试一遍（虽然真的很蠢，但是我真的想不出到底能怎么办了）

第二点因为不存在循环则使用遗传算法需要设定一个相当长的染色体长度（我们设定的染色体是RGV为各台CNC上下料的次序，如果要考虑全过程的模拟退火遗传算法，则染色体长度大约在300~400左右）。事实上我也尝试了这个方法，结果从我写完这个算法我开始跑，一直跑到比赛结束算法依旧没有收敛[捂脸]。这里给出代码仅供参考（各位朋友要是有好意见也可以提出） ↓↓↓
$ L3 r6 R( L6 q( K$ P
+ F0 E2 \. Z4 }6 W# -*- coding:UTF-8 -*-
' g. [5 l& b- V. p8 t"""
        作者：囚生CY
, X9 U5 `& X8 q        平台：CSDN
        时间：2018/10/09
        转载请注明原作者
        创作不易，仅供分享
"""
import random

& ?8 l3 A$ O/ e- y# 第1组
) p. ?! H& R! M6 ?( F' p"""
d1 = 20
# Q; ]9 D8 o. _' Z) jd2 = 33
: O5 J* y1 O) j" r3 J- fd3 = 46
T1 = 400
T2 = 378
To = 28
Te = 31
  `- x9 X3 |  V$ X8 c4 L2 lTc = 25
"""
3 x7 G- P# O/ ?5 e  J# ^4 d! ]+ q' `
# 第2组
"""
d1 = 23
d2 = 41
$ t: n7 i4 e% y4 s: w" Hd3 = 59
, G1 P6 k) I' i: DT1 = 280
0 i) c# ?0 y3 V5 `2 Q! h$ kT2 = 500
& M, b9 N9 o1 R' S# r: Y& hTo = 30
# t, Q7 [5 E; ]4 m: L" \+ {$ f2 i) x2 vTe = 35
8 I. r1 B& l# G! x" m' HTc = 30
* k: Z; D+ p! U+ x' U% z* {"""
3 _  T# X" }7 N5 s
# 第3组
d1 = 18
: \9 K0 ?9 E* J9 e- d7 Yd2 = 32
d3 = 46
T1 = 455
T2 = 182
9 H6 L0 K7 |0 f' O, R: OTo = 27
0 b# k) z2 ^- o0 vTe = 32
Tc = 25
! H9 O& h- T% c% P: g: f
cncT = [To,Te,To,Te,To,Te,To,Te]
tm = [
% A- @; X; E1 U; O0 V8 ?6 g% W' T        [0,0,d1,d1,d2,d2,d3,d3],
8 ]# h: _6 d- L; ], k6 \4 r& u        [0,0,d1,d1,d2,d2,d3,d3],
! t$ D' M- ?) C9 x; z0 \2 {        [d1,d1,0,0,d1,d1,d2,d2],
        [d1,d1,0,0,d1,d1,d2,d2],
        [d2,d2,d1,d1,0,0,d1,d1],
* s, c/ \$ ^- y5 x  Q! F        [d2,d2,d1,d1,0,0,d1,d1],
        [d3,d3,d2,d2,d1,d1,0,0],
        [d3,d3,d2,d2,d1,d1,0,0],
$ P! d" G) h! ^6 V/ S]
; t; D9 b: v! W8 u. P  _1 m3 X) aType = [1,0,1,0,1,0,0,0]                                                                                                 # CNC刀具分类

N = 64
9 @: ~0 L6 ^/ vL = 100
varP = 0.1
croP = 0.6
/ E+ W8 Y) Y3 N- Z) F% b7 HcroL = 2
$ i5 T2 a4 V7 G, k1 O- Be = 0.99

def init_first_round():                                                                                                         # 第一圈初始化（默认把所有第一道CNC按顺序加满再回到当前位置全部加满）
        state = [0 for i in range(8)]                                                                                   # 记录CNC状态（还剩多少秒结束，0表示空闲）
# T/ z( b( k. E1 \4 t        isEmpty = [1 for i in range(8)]                                                                                 # CNC是否为空
- V" j/ |. w& j1 U        rgv = 0                                                                                                                                 # rgv状态（0表示空车，1表示载着半成品）
, x7 g; R6 r3 k; o# B; e  N: B* N        currP = 0
& v) T/ M: d, r& j! g        total = 0
        seq = []
9 _0 h  ]7 b3 b        flag = False
/ {8 Y2 [. L" q& r        for i in range(len(Type)):
4 R9 P% K& M9 z/ p/ m                if Type==0:
                        seq.append(i)
1 }7 S2 b+ s: @$ M: f3 q                        flag = True
& h& b0 ?% m$ l/ O+ c        currP = seq[0]
' y& W4 V9 L. q$ s$ E3 R; b$ W        seq.append(currP)
        rgv,currP,total = time_calc(seq,state,isEmpty,rgv,currP,total)
        return state,isEmpty,rgv,currP,total,seq

4 c4 S5 M7 A1 s, Odef update(state,t):
        for i in range(len(state)):
                if state < t:
# @# m# Z: y+ w) g+ q6 i% ^                        state = 0
) C( N9 m# j6 I  S4 h6 \! N' d* z. k                else:
                        state -= t

def time_calc(seq,state,isEmpty,rgv,currP,total):                                                 # 事实上sequence可能是无效的，所以可能需要
4 e3 Q8 }5 F0 ^: c( N        index = 0
% P9 d* e3 K! I8 W$ e, O1 s, n        temp = 0
6 j4 f( U4 _2 i5 L& b2 O        while index<len(seq):
7 @. A  M3 d2 b9 e$ s7 n                """ 先移动到下一个位置 """
" v3 I( K5 Q7 F! l# X                nextP = seq[index]
" c0 l# i, g5 K( q( P3 o8 ~$ T                t = tm[currP][nextP]
                total += t
7 h  c+ q5 Z6 h9 P. V8 M6 M+ n$ x                update(state,t)
                if Type[nextP]==0:                                                                                                 # 如果下一个位置是第一道工作点
& R8 c1 r5 P8 U) `3 `( R0 k                        if rgv==1:                                                                                                         # 然而载着半成品
) z8 i+ j8 G6 z                                seq.pop(index)                                                                                         # 去掉这个元素并中止当次循环进入下一个循环
                                continue                               
                        if isEmpty[nextP]:                                                                                         # 如果下一个位置是空的
                                t = cncT[nextP]
% R" \; w. a% p& S                                total += t
                                update(state,t)
                                state[nextP] = T1                                                                                 # 更新当前的CNC状态
+ z3 {/ j; }3 `( U                                isEmpty[nextP] = 0                                                                                 # 就不空闲了
                        else:                                                                                                                 # 如果没有空闲
! g; r2 _/ S- f                                if state[nextP] > 0:                                                                         # 如果还在工作就等待结束
                                        t = state[nextP]
& u0 R- H2 J2 z- U                                        total += t
" t4 N2 o1 F2 g& e& g                                        update(state,t)
                                t = cncT[nextP]                                                                                         # 完成一次上下料
- B" E; e" P/ b; O" f0 C! o                                total += t
                                update(state,t)
                                state[nextP] = T1
) [8 q5 M2 d4 C+ b: W5 `. d4 s% L& u" g                                rgv = 1
. b7 ^& u5 T) t1 v" m' L; X" o                else:                                                                                                                         # 如果下一个位置是第二道工作点
- }$ H! H6 N+ z  q4 l                        if rgv==0:                                                                                                         # 如果是个空车
                                seq.pop(index)                                                                                         # 删除当前节点
1 ]: G8 j% b# B# m  w0 ?; {                                continue
                        if isEmpty[nextP]:                                                                                         # 如果下一个位置是空的
! Y8 ]; a3 w6 E/ E" ^                                t = cncT[nextP]
/ q% I! ^( ~! c( t/ r                                total += t
2 X0 v& i# u" ?  M3 }9 B! U                                update(state,t)
) `( a0 `4 G8 Y! ^: l                                state[nextP] = T2
6 A( R/ j5 h$ @% N                                isEmpty[nextP] = 0       
                        else:                                                                                                                 # 如果没有空闲
& F: }" l! [* T4 O# ?4 H2 j1 J& e7 s- q                                if state[nextP] > 0:                                                                         # 如果还在工作就等待结束
4 f/ t, J9 h! s                                        t = state[nextP]
                                        total += t
  i# R: C: N$ Z& ^+ }( {1 E$ [- r7 ?, g                                        update(state,t)
                                t = cncT[nextP]+Tc
& H3 V, b8 ?. k$ ^                                total += t
                                update(state,t)
9 ~7 {+ ?" s4 P( @2 d$ k                                state[nextP] = T2
; d' x! ], {+ Y                        rgv = 0
0 [) {' e" I. r- K                currP = nextP
3 ^7 T* Q# L, U" f                temp = total
; P* q9 ]5 P6 p+ P, y" D3 ~6 j. B                index += 1       
        total += tm[currP][Type.index(0)]                                                                         # 最后归零
& `6 w1 r* e- ^, E        return rgv,currP,total
# H9 J  q3 \$ m  p3 O9 v
def init_prob(sample,state,isEmpty,rgv,currP,total):                                         # 计算所有sample的
        prob = []
        for seq in sample:
: M- e3 p  I  K                t = time_calc(seq,state[:],isEmpty[:],rgv,currP,total)[-1]
) _9 G  A( P' h  x* x- z                prob.append(t)
% @0 j7 r' j4 w) q' D. }6 T: C        maxi = max(prob)
        prob = [maxi-prob+1 for i in range(N)]
        temp = 0
        for p in prob:
                temp += p
        prob = [prob/temp for i in range(N)]
9 N2 C; K9 H* p        for i in range(1,len(prob)):
! g1 V. N4 c1 ]                prob += prob[i-1]
        prob[-1] = 1                                                                                                                 # 精度有时候很出问题
# ]2 t* T2 z! V        return prob

8 r8 Z1 T+ F! edef minT_calc(sample,state,isEmpty,rgv,currP,total):
; a+ C% S/ w  o4 U0 T, H$ K        minT = time_calc(sample[0],state[:],isEmpty[:],rgv,currP,total)[-1]
        index = 0
        for i in range(1,len(sample)):
0 V; y# L+ }$ [) q6 @                t = time_calc(sample,state[:],isEmpty[:],rgv,currP,total)[-1]
                if t < minT:
" Q7 a" R  Q# |; s5 n0 Y                        index = i
2 {( z  F8 Y' [4 B                        minT = t
- F4 v8 J, U, N7 }% a% h, k        return minT,index
       
def init():                                                                                                                                 # 初始化种群（按照第二道工序，第一道工序，第二道工序，第一道工序顺序排列即可）
$ D) e3 l& Q+ e0 H2 t+ K& T' O        sample = []
        refer0 = []
3 d- T# Q! D; m1 k3 @* c( o        refer1 = []
& H2 c2 i8 e; A8 i9 K  a8 B        for i in range(8):
                if Type==0:
                        refer0.append(i)
5 \! ~8 d) V) n* n                else:
                        refer1.append(i)
, Y2 i8 {0 T# C7 |- b7 N        for i in range(N):
                sample.append([])
# ^4 M7 t' b% X- S                for j in range(L):
5 E, H1 Y" x: k                        if j%2==0:
                                sample[-1].append(refer1[random.randint(0,len(refer1)-1)])
8 W( X" {4 o" @                        else:
. k# y  [/ c  X, [* \& l5 e                                sample[-1].append(refer0[random.randint(0,len(refer0)-1)])
        return sample

! z' z1 j7 Z3 m, n9 o, C0 rdef select(sample,prob):                                                                                                 # 选择算子
- U( c7 l/ D1 b/ c* u        sampleEX = []
  e& Q4 H7 ]- R& O8 F' Q( i0 X        for i in range(N):                                                                                                         # 取出N个样本
! y1 F. j9 S, @0 M- `                rand = random.random()
                for j in range(len(prob)):
5 u  U+ Q+ X9 _8 T                        if rand<=prob[j]:
                                sampleEX.append(sample[j])
6 D* c; j2 v- |4 R! v4 i8 T; Q                                break
& ?9 c, i3 f' q5 S0 G8 ]  \        return sampleEX

2 {$ R  u( D6 |' O# H& ]def cross(sample,i):                                                                                                         # 交叉算子
        for i in range(len(sample)-1):
0 u/ ~9 n9 l4 P/ }                for j in range(i,len(sample)):
                        rand = random.random()
                        if rand<=croP*(e**i):                                                                                 # 执行交叉
/ G, j0 \7 x* W                                loc = random.randint(0,L-croL-1)
1 F8 p/ u2 p7 H4 ?1 t6 v5 C                                temp1 = sample[loc:loc+croL]
4 p  n8 J8 N/ P. `                                temp2 = sample[j][loc:loc+croL]
                                for k in range(loc,loc+croL):
                                        sample[k] = temp2[k-loc]
                                        sample[j][k] = temp1[k-loc]
; e9 f# \* F7 P6 \2 V- s, g        return sample
               
* U* Z  L" x' O% j  {9 p4 _+ idef variance(sample,i):                                                                                                         # 变异算子                                                                                 
        for i in range(len(sample)):
' l; A; H- g: ^, G2 @4 c                rand = random.random()
                if rand<varP*(e**i):
9 A. Q4 i! Q+ G3 x0 {                        rand1 = random.randint(0,L-1)
7 B2 z1 w: A1 f                        randTemp = random.randint(0,int(L/2)-1)
                        rand2 = 2*randTemp if rand1%2==0 else 2*randTemp+1
8 D5 h0 V# C) T- A/ z                        temp = sample[rand1]
                        sample[rand1] = sample[rand2]
: u- o' u" [) j* e) N' `                        sample[rand2] = temp
4 }* @9 B' U6 ]8 q' q! |4 O        return sample

if __name__ == "__main__":
4 F; x6 p; y1 I- ~        state,isEmpty,rgv,currP,total,seq = init_first_round()
) z& p; P! m" d4 X/ K        print(state,isEmpty,rgv,currP,total)
9 Q4 ]& I7 F0 Y! p% \        sample = init()
        mini,index = minT_calc(sample,state[:],isEmpty[:],rgv,currP,total)       
2 L5 f$ a2 W2 m+ R' Z" r7 ~        best = sample[index][:]
        for i in range(100000):
& o2 l9 V+ X2 d! s, E% I# \4 k                f = open("GA.txt","a")
, F) \/ Y' n6 G0 P" l9 {( q                tmin = minT_calc(sample,state[:],isEmpty[:],rgv,currP,total)[0]
                f.write("{}\t{}\n".format(i,tmin))
                print(i,"\t",tmin,end="\t")
                prob = init_prob(sample,state[:],isEmpty[:],rgv,currP,total)
                sample = select(sample,prob)
( ?7 |& d* u9 g  H; [" A                sample = cross(sample,i)
                sample = variance(sample,i)
                mi,index = minT_calc(sample,state[:],isEmpty[:],rgv,currP,total)
) `: Y) S9 g# G) [( o                if mi>mini and random.random()<e**i:                                                         # 精英保留策略
                        rand = random.randint(0,N-1)
/ I# }2 @5 |7 M; _                        sample[rand] = best[:]
, i! [2 f7 K; H( v9 `                mini,index = minT_calc(sample,state[:],isEmpty[:],rgv,currP,total)
9 Y! X6 U7 E. q, H( ?2 Z: x2 x. ]                best = sample[index][:]
                print(best)
1 B7 Q9 e% B' O3 F' _                f.close()
        print(sample)
2 B, Y+ Z, S% I( G3 s4 g+ [遗传算法这条路被堵死后我一度陷入俗套，用最直接的贪心搞了一阵子，觉得用贪心算法（即考虑下一步的最优策略）实在是对不起这种比赛。然后我就变得——更贪心一点了。

3 V  n9 k' c0 f我试图去寻找接下来K步最优的策略，然后走一步。K=1时算法退化为贪心算法，最终我们设置为K=4（当K>=8时算法速度已经相当缓慢，而4~7的结果大致相同，且K=4的速度基本可以做到2秒内得到结果）。

值得注意的是我假设RGV在两道工序下只能由第一道工序的CNC到第二道工序的CNC（忽略清洗时间情况下），然后回到第一道工序的CNC，这样往复移动（这里我不说明为什么一定要这样，但是我认为确实应该是这样）。在这个规律的引导下我大大减缩了代码量以及计算复杂度。

1 c& [4 W) h6 @然后到第四种情况我们已经没有多余时间了，只能延续使用情况三的算法，进行了随机模拟的修改，完成了第四种情况的填表。
$ A* m& }0 X7 S2 V, ^
以下是第三种情况的代码（第四种类似就不上传了）↓↓↓
- I$ Q1 K5 z* w
#coding=gbk
import random
: q" J, P' ]7 s' X5 R0 _# -*- coding:UTF-8 -*-
"""
        作者：囚生CY
        平台：CSDN
# e, n: c( _4 c7 N& a        时间：2018/10/09
        转载请注明原作者
        创作不易，仅供分享
"""
$ q3 q5 D, Y' O4 `! V& {from tranToXls import *
+ c/ A3 u4 D9 s0 P; k' d8 h; G. @4 s
# 第1组
"""
# I" |  C) r: }# C1 X) `! d5 G" _d1 = 20
d2 = 33
2 e5 S6 `$ X* G5 P' i# e% l( W+ }6 fd3 = 46
T1 = 400
4 v% E7 W9 A$ b1 c7 c% aT2 = 378
; ]: r1 }6 \0 ?9 l- M* t$ P* HTo = 28
/ a5 F  j* U+ y/ eTe = 31
Tc = 25
"""
# 第2组
, h& N: v3 }6 O5 m* p' g9 R
d1 = 23
d2 = 41
d3 = 59
* i0 N) W: Q, l+ c$ GT1 = 280
- G- f' {3 l# G' AT2 = 500
To = 30
" l" j5 V/ g& F6 oTe = 35
Tc = 30
* E$ O1 p8 i3 U0 j0 O! n

6 I6 l" }1 N) b- c+ u) x# 第3组
$ K$ {2 @" I7 t0 E: _2 k
"""
d1 = 18
7 l3 u, k6 B- A9 p8 y  }4 fd2 = 32
d3 = 46
T1 = 455
T2 = 182
To = 27
Te = 32
Tc = 25
$ W) \2 D2 [6 A3 {) ["""

cncT = [To,Te,To,Te,To,Te,To,Te]
tm = [
        [0,0,d1,d1,d2,d2,d3,d3],
        [0,0,d1,d1,d2,d2,d3,d3],
9 ]7 u0 \  L! D4 T- C6 [& R: v        [d1,d1,0,0,d1,d1,d2,d2],
        [d1,d1,0,0,d1,d1,d2,d2],
        [d2,d2,d1,d1,0,0,d1,d1],
        [d2,d2,d1,d1,0,0,d1,d1],
        [d3,d3,d2,d2,d1,d1,0,0],
        [d3,d3,d2,d2,d1,d1,0,0],
]
Type = [0,1,0,1,1,1,0,1]                                                                                                 # CNC刀具分类
6 p: j. X9 Y$ O4 U! F( ^
A = []                                                                                                                                         # 储存第一道工序的CNC编号
. r8 E' [# P0 N" p& r, MB = []                                                                                                                                         # 储存第二道工序的CNC编号
& [4 n" b( S) b5 ]) ofor i in range(len(Type)):
8 \2 H, S: T( C" c4 a- L' |# E. V        if Type:
                B.append(i)
- ^. p, }! H  ]* s5 A        else:
. v8 h9 z) j& J1 z& q- @3 O, V; T                A.append(i)
3 Z+ [" M  j; `
5 @5 |& q: m" l/ @; rdef init_first_round():                                                                                                         # 第一圈初始化（默认把所有第一道CNC按顺序加满再回到当前位置全部加满）
        state = [0 for i in range(8)]                                                                                   # 记录CNC状态（还剩多少秒结束，0表示空闲）
- [' R4 m5 f, Q" N/ E        isEmpty = [1 for i in range(8)]                                                                                 # CNC是否为空
        log = [0 for i in range(8)]                                                                                         # 记录每台CNC正在加工第几件物料
        count1 = 0
1 Q  c; L6 r7 i5 W7 O9 q) e+ [% T        rgv = 0                                                                                                                                 # rgv状态（0表示空车，1表示载着半成品）
  R& K- h/ S; ?1 r  z& c+ v# S        currP = 0
        total = 0
        seq = []
. V; Y% o+ S8 |; a( I        flag = False
        for i in range(len(Type)):
0 V- q: I# P/ d) b2 [/ v, L                if Type==0:
                        seq.append(i)
6 X8 R! R3 l5 k0 @$ C" V0 R$ ^4 J  t: {6 J                        flag = True
  v6 n2 l: Q9 v" f5 s! j        currP = seq[0]
0 ~$ g' k+ `, p1 P$ \% p/ \        seq.append(currP)
  y. }3 n* r1 Y! u4 \) i. Z) M        count1,rgv,currP,total = simulate(seq,state,isEmpty,log,count1,rgv,currP,total)
        return state,isEmpty,log,count1,rgv,currP,total,seq
" z7 s/ e/ J: {  b2 I. T  r
0 O% t# c6 D# l, [: Kdef update(state,t):
; t8 Z" d' ]7 ]3 @        for i in range(len(state)):
                if state < t:
+ _8 J7 G6 X1 p) v+ |/ Z                        state = 0
                else:
, m5 l9 [" p: f: g; }                        state -= t

. i5 J+ G# i& g% L' Ldef simulate(seq,state,isEmpty,log,count1,rgv,currP,total,fpath="log.txt"):        # 给定了一个序列模拟它的过程以及返回结果（主要用于模拟并记录）
6 s! k- C4 j9 h7 ~; L5 N7 v" m        index = 0
        temp = 0
        pro1 = {}                                                                                                                         # 第一道工序的上下料开始时间
, J7 b" y+ B  y* Q7 A+ n        pro2 = {}                                                                                                                         # 第二道工序的上下料开始时间
% H, u0 C0 n( G        f = open(fpath,"a")
        while index<len(seq):
                print(isEmpty)
! D% p2 J8 Z  p: b7 i% ~                nextP = seq[index]
" |8 E9 M4 n6 Z$ r                t = tm[currP][nextP]
                total += t
0 N3 K# M/ y& f. R% L                update(state,t)
" m" t* P) I' t+ V! z5 a                if Type[nextP]==0:                                                                                                 # 如果下一个位置是第一道工作点
                        count1 += 1
$ N2 h: s8 C+ k8 Y; q, @; J- p7 V                        if isEmpty[nextP]:                                                                                         # 如果下一个位置是空的
! I/ q# \4 j# @. [                                f.write("第{}个物料的工序一上料开始时间为{}\tCNC编号为{}号\n".format(count1,total,nextP+1))
                                t = cncT[nextP]
                                total += t
                                update(state,t)
                                state[nextP] = T1                                                                                 # 更新当前的CNC状态
                                isEmpty[nextP] = 0                                                                                 # 就不空闲了
9 Z, j  _, D& D                        else:                                                                                                                 # 如果没有空闲
7 R( w" Q/ D$ j( g( A& W2 r                                if state[nextP] > 0:                                                                         # 如果还在工作就等待结束
                                        t = state[nextP]
" z% c4 X3 J8 }3 g, b                                        total += t
. v6 S% _" S+ K* }& I" ?  L                                        update(state,t)
                                f.write("第{}个物料的工序一下料开始时间为{}\tCNC编号为{}号\n".format(log[nextP],total,nextP+1))
                                f.write("第{}个物料的工序一上料开始时间为{}\tCNC编号为{}号\n".format(count1,total,nextP+1))
7 j4 [3 m$ m( _& q4 v7 W                                t = cncT[nextP]                                                                                         # 完成一次上下料
                                total += t
6 [0 ^. V( f3 o. x% K                                update(state,t)
, {& P5 G- ]0 i( ~! u                                state[nextP] = T1
                                rgv = log[nextP]
- {" T: b% z9 h; P$ p                        log[nextP] = count1
! h8 O' B1 N% z) K+ K/ B7 o                else:                                                                                                                         # 如果下一个位置是第二道工作点
                        if isEmpty[nextP]:                                                                                         # 如果下一个位置是空的
                                f.write("第{}个物料的工序二上料开始时间为{}\tCNC编号为{}号\n".format(rgv,total,nextP+1))
                                t = cncT[nextP]
                                total += t
                                update(state,t)
6 E. P' R0 E9 j7 F! o                                state[nextP] = T2
- t: s. w# A% T, e+ ^! g# U                                isEmpty[nextP] = 0       
+ k& V; C, y9 m6 ]1 h                        else:                                                                                                                 # 如果没有空闲
5 w. {# G4 M8 X( ]                                f.write("第{}个物料的工序二下料开始时间为{}\tCNC编号为{}号\n".format(log[nextP],total,nextP+1))
, u; r3 y; {1 \$ @: G                                f.write("第{}个物料的工序二上料开始时间为{}\tCNC编号为{}号\n".format(rgv,total,nextP+1))
. z) G+ L, l( X! g4 g8 h7 H                                if state[nextP] > 0:                                                                         # 如果还在工作就等待结束
% g  g/ E( H+ I: i8 N1 P8 F                                        t = state[nextP]
* `: t! A  @8 a* H; D( i                                        total += t
                                        update(state,t)
! U2 s4 t1 A! u/ Y# ]- y9 |                                t = cncT[nextP]+Tc
& Y- S6 B4 v9 K- H! f/ s& l+ r                                total += t
! B" o/ X. G* p! H5 q                                update(state,t)
5 l9 _: H( _" Y( E! n! N                                state[nextP] = T2
                        log[nextP] = rgv
                        rgv = 0
; x, ~% A" t7 A* T                currP = nextP
; n0 C6 }  c. W7 }; @5 Z* x                temp = total
4 o! n$ M' T) u* Q8 w! A                index += 1       
        f.close()
8 N0 M7 f0 h% w0 P        total += tm[currP][Type.index(0)]                                                                         # 最后归到起始点
        return count1,rgv,currP,total
* l7 E8 R% ^+ i+ s# n. {) I5 I
def time_calc(seq,state,isEmpty,rgv,currP,total):                                                 # 主要用于记录时间
: }1 |' g2 Y* B5 X        index = 0
/ ]0 M1 r' X  v: ^! l; x+ r        temp = 0
        while index<len(seq):
                nextP = seq[index]
; D, \: u& Z% N" c, ]6 {% ~% a/ Z9 ]                t = tm[currP][nextP]
8 k( F$ l4 H& }# S8 N& n                total += t
3 @. a8 ~" h% b4 N* y3 `                update(state,t)
$ f' T: {  b6 m* h                if Type[nextP]==0:                                                                                                 # 如果下一个位置是第一道工作点
                        if rgv==1:                                                                                                         # 然而载着半成品
                                seq.pop(index)                                                                                         # 去掉这个元素并中止当次循环进入下一个循环
/ \0 E* o) K# N; V                                continue                               
! d- j  m- ~2 I: z9 w6 R! \2 o                        if isEmpty[nextP]:                                                                                         # 如果下一个位置是空的
                                t = cncT[nextP]
# E$ T5 W! t+ k2 q$ `2 Z                                total += t
                                update(state,t)
& I) O% _4 W4 {, c                                state[nextP] = T1                                                                                 # 更新当前的CNC状态
                                isEmpty[nextP] = 0                                                                                 # 就不空闲了
" o+ Z% a. j1 L; f' y# P                        else:                                                                                                                 # 如果没有空闲
                                if state[nextP] > 0:                                                                         # 如果还在工作就等待结束
# l+ x7 @8 J, x                                        t = state[nextP]
2 ^. Z" [) E* @; `# Q                                        total += t
                                        update(state,t)
                                t = cncT[nextP]                                                                                         # 完成一次上下料
                                total += t
/ {3 C) S# G3 R! l2 n% I                                update(state,t)
                                state[nextP] = T1
                                rgv = 1
                else:                                                                                                                         # 如果下一个位置是第二道工作点
( {% w3 c' {$ u1 |) j/ g                        if rgv==0:                                                                                                         # 如果是个空车
, X2 B% r2 Z4 g, D( B                                seq.pop(index)                                                                                         # 删除当前节点
                                continue
" {" [. W, y( m2 e/ J7 c                        if isEmpty[nextP]:                                                                                         # 如果下一个位置是空的
7 M7 y+ g! @% l                                t = cncT[nextP]
+ c* R; X/ b  {5 j+ s7 U) _                                total += t
( X3 ~! h/ K% X; p0 _                                update(state,t)
                                state[nextP] = T2
                                isEmpty[nextP] = 0       
# D  T. y- Y% L& E                        else:                                                                                                                 # 如果没有空闲
                                if state[nextP] > 0:                                                                         # 如果还在工作就等待结束
3 S+ a1 @* r% F$ |! Z& ~7 T9 t                                        t = state[nextP]
4 b. Y6 Q$ h3 T" w3 v' T                                        total += t
6 V0 B1 E; L% ?( r7 L2 s0 b                                        update(state,t)
2 K9 w: J1 v  A8 z' r8 Q& E8 b                                t = cncT[nextP]+Tc
                                total += t
% a/ r2 X* _  u' G2 W; o4 o                                update(state,t)
                                state[nextP] = T2
                        rgv = 0
                currP = nextP
1 w" n2 u. \5 o8 i8 I% \/ U- K; f                temp = total
7 |) B* ]# f& {: E9 q                index += 1       
        return rgv,currP,total

7 N, ^. c# E- h% Idef forward1(state,isEmpty,currP):                                                                                 # 一步最优
7 T- n! s5 \3 C        lists = []
        if currP in A:
                rgv = 1
) ?( ^, ~: F9 K* t9 K! `5 |) W                for e1 in B:
% J; D" T' T$ g4 U6 ~5 g3 L' J                        lists.append([e1])
       
0 @" u. p/ Q- Y+ z4 G$ D2 _- Z        else:
% `) z$ k# p1 O8 \; S% B                rgv = 0
; Y2 k  i+ c# U" S( G                for e1 in A:
- R1 ^1 y* a& {                        lists.append([e1])
       
+ A2 f8 c) t, Z6 V        minV = 28800
        for i in range(len(lists)):
                t = time_calc(lists,state[:],isEmpty[:],rgv,currP,0)[-1]
                if t<minV:
- ?: X1 T$ \' ^9 k                        minV = t
                        index = i
( a3 X, k% u$ l( [4 x' T4 j2 t        return lists[index][0]
2 V* S; i% B/ X5 k6 y
! x8 S. |0 z2 x$ Rdef forward4(state,isEmpty,currP):                                                                                 # 四步最优
        lists = []
        """ 遍历所有的可能性 """
) R5 B! H' ]/ J1 b        if currP in A:                                                                                                                 # 如果当前在第二道工序CNC的位置
                rgv = 1
. [" s  S3 E  c% A+ F0 H  Q8 s5 f0 [                for e1 in B:
3 }$ o! n. p$ V                        for e2 in A:
                                for e3 in B:
                                        for e4 in A:
2 f4 _. _8 p& m6 l" O# n                                                lists.append([e1,e2,e3,e4])
        else:
  Q) {% _! q" y" i                rgv = 0
                for e1 in A:
                        for e2 in B:
1 b# M' P/ q! n. {9 |# x4 a7 T+ O/ e                                for e3 in A:
, L. W+ z$ G5 m4 f5 }                                        for e4 in B:
                                                lists.append([e1,e2,e3,e4])
7 ~" Z2 G: e9 W  Y$ s9 b7 G        minV = 28800
7 S; f) C" d! f: f: e' @        for i in range(len(lists)):
& f* Y+ b) d( h; D' @) s- R( j                t = time_calc(lists,state[:],isEmpty[:],rgv,currP,0)[-1]
  v! c/ p. {. K: T                if t<minV:
                        minV = t
  u/ o7 T) v! Q0 I# E7 e9 M" Q                        index = i
        return lists[index][0]                                                                                                 # 给定下一步的4步计算最优

* n# H1 i- x8 a3 b9 C& Ydef forward5(state,isEmpty,currP):                                                                                 # 五步最优
        lists = []
        """ 遍历所有的可能性 """
        if currP in A:                                                                                                                 # 如果当前在第二道工序CNC的位置
4 }/ \* Q4 e/ b: |7 s                rgv = 1
                for e1 in B:
- s; q$ z1 j1 a" [! T  ^6 ?                        for e2 in A:
; X0 b/ ~0 ]$ I" {5 {3 P  p( h5 ]                                for e3 in B:
  f/ c: T+ T' H& K  a( C                                        for e4 in A:
3 _1 T& `5 Z3 F5 }; j% |# K                                                for e5 in B:
6 u3 }- C2 d! g7 l                                                        lists.append([e1,e2,e3,e4,e5])
        else:
' [  ?9 K7 d% P% k  S2 Y5 h                rgv = 0
( {) ]7 F+ v, j. Q. M                for e1 in A:
3 p* a6 z, d0 O                        for e2 in B:
                                for e3 in A:
                                        for e4 in B:
& R' |4 _4 t0 |8 R7 G5 T6 ~                                                for e5 in A:
  ~( H: Y+ _0 D! M                                                        lists.append([e1,e2,e3,e4,e5])
        minV = 28800
        for i in range(len(lists)):
" g# q1 m0 I. }1 b3 V0 z0 @8 a6 k                t = time_calc(lists,state[:],isEmpty[:],rgv,currP,0)[-1]
                if t<minV:
; S8 S4 i% |, e4 k) ^                        minV = t
3 o# S0 U- _+ b' B' ~                        index = i
        return lists[index][0]                                                                                                 # 给定下一步的5步计算最优

, `( ^! \/ K, z& h4 edef forward6(state,isEmpty,currP):                                                                                 # 六步最优
3 i* I) e: e# n1 x1 b        lists = []
        """ 遍历所有的可能性 """
' a/ }. Q1 g& Q- m- n3 U        if currP in A:                                                                                                                 # 如果当前在第二道工序CNC的位置
                rgv = 1
8 W. p( f" Y# |  b& s) [* k                for e1 in B:
                        for e2 in A:
                                for e3 in B:
% }4 L# w; o* ~7 v' T4 Y                                        for e4 in A:
8 }& j' K7 H  i! H+ N* o                                                for e5 in B:
                                                        for e6 in A:
                                                                lists.append([e1,e2,e3,e4,e5,e6])
7 T4 u. c8 O. d5 R, v; Q        else:
4 a( m7 q% |- e! m0 ~; `; _/ p                rgv = 0
                for e1 in A:
                        for e2 in B:
, x, ?+ c& R$ t: O& O                                for e3 in A:
                                        for e4 in B:
3 @. d8 Q$ I9 E2 X* ~                                                for e5 in A:
2 v" ?. \2 y- @                                                        for e6 in B:
) ?2 U! }' E; j' a                                                                lists.append([e1,e2,e3,e4,e5,e6])
0 N+ i) n. Q9 F8 g        minV = 28800
        for i in range(len(lists)):
                t = time_calc(lists,state[:],isEmpty[:],rgv,currP,0)[-1]
- ^* f9 a3 Q. F+ M                if t<minV:
                        minV = t
0 K8 A8 n% B. a; D( i  t8 @0 r. u& K                        index = i
        return lists[index][0]                                                                                                 # 给定下一步的6步计算最优
6 k1 g$ E0 y+ v9 q
6 P* S% ]- s8 I( m9 j3 Cdef forward7(state,isEmpty,currP):                                                                                 # 七步最优
, b" W9 ?: V) {3 b. f2 ]        lists = []
  I9 Z) V% S0 V8 B/ ~( I, J        """ 遍历所有的可能性 """
! E7 y& A% r; R/ p; k: g  V" Q  s        if currP in A:                                                                                                                 # 如果当前在第二道工序CNC的位置
( b  s  d  E1 T# S7 j                rgv = 1
9 j0 S' @+ I0 `' ~# u* p                for e1 in B:
                        for e2 in A:
( O1 k/ w, Z: J$ U+ _  R                                for e3 in B:
! [4 E  G. S; C* ^. |, }% z                                        for e4 in A:
                                                for e5 in B:
4 p" ?9 s  h6 o4 i                                                        for e6 in A:
                                                                for e7 in B:
* i, O, N( G- {+ e! g' @                                                                        lists.append([e1,e2,e3,e4,e5,e6,e7])
        else:
) y- w! g* Y' U4 E8 L8 C                rgv = 0
                for e1 in A:
                        for e2 in B:
/ B8 p: Q* m2 [; z9 M                                for e3 in A:
7 Y& z7 c2 e2 G, b5 r4 q# h5 F! B                                        for e4 in B:
4 v. Z8 l9 X- s1 D7 ]                                                for e5 in A:
* N3 q& U( C" q' ?) j. ?6 W                                                        for e6 in B:
" q+ T$ ?1 e7 U5 N3 j2 ?; `                                                                for e7 in A:
                                                                        lists.append([e1,e2,e3,e4,e5,e6,e7])
! ?% |2 N1 H5 q# H! |# I/ Z        minV = 28800
        for i in range(len(lists)):
* P) {" @3 e2 l; [                t = time_calc(lists,state[:],isEmpty[:],rgv,currP,0)[-1]
                if t<minV:
                        minV = t
                        index = i
        return lists[index][0]                                                                                                 # 给定下一步的7步计算最优
: [& o5 o* }9 O  E5 E
def forward8(state,isEmpty,currP):                                                                                 # 八步最优
        lists = []
: u. |# o$ V5 M+ s7 w0 U+ Q- V( X        """ 遍历所有的可能性 """
        if currP in A:                                                                                                                 # 如果当前在第二道工序CNC的位置
, \! p7 P* v' n* r                rgv = 1
+ v  p  n) d/ f                for e1 in B:
* Z& D5 E1 J1 ~* }: G                        for e2 in A:
                                for e3 in B:
- Y( _2 G% u6 {& E! W& E; s                                        for e4 in A:
2 C$ E/ T, Q+ l" l' ^4 ~                                                for e5 in B:
+ e2 n1 F4 e& _- j& a                                                        for e6 in A:
6 g0 ^+ i5 Y! k( G, `                                                                for e7 in B:
  `9 a: l2 U: h1 c5 O8 q) H6 `: ?                                                                        for e8 in A:
; D( ^' U& D6 |" C                                                                                lists.append([e1,e2,e3,e4,e5,e6,e7,e8])
        else:
                rgv = 0
2 U/ O# A4 A# F: D! M                for e1 in A:
0 ~' B! V) _5 a0 D5 r) J8 @9 q5 Z                        for e2 in B:
                                for e3 in A:
: @9 v3 L9 W& S' b5 g3 Q                                        for e4 in B:
9 M" X4 U  _* N9 w2 q                                                for e5 in A:
& {. M) K4 u! R" E                                                        for e6 in B:
% d8 v- W/ V' Z$ f2 C2 ~4 a                                                                for e7 in A:
                                                                        for e8 in B:
                                                                                lists.append([e1,e2,e3,e4,e5,e6,e7,e8])
5 x* m3 R( o: ^9 c& H) Q        minV = 28800
        for i in range(len(lists)):
" N" E) S4 n( E6 z6 E) i                t = time_calc(lists,state[:],isEmpty[:],rgv,currP,0)[-1]
* b1 A$ w8 W/ F/ S, y0 u; z                if t<minV:
                        minV = t
8 ?/ P0 j/ F0 T2 v                        index = i
) P( t. D) L# C* h: ?        return lists[index][0]                                                                                                 # 给定下一步的8步计算最优
) W9 ^. v5 d6 Z; `! x8 h1 t' q9 `2 ?
6 w* d/ ^, }% n3 R( x) Bdef greedy(state,isEmpty,rgv,currP,total):                                                                 # 贪婪算法
        line = []
+ S: F( S& S  w# y+ R        count = 0
7 i4 z: s, G$ W4 Y" c        while True:
5 u1 x! |# \) J2 L/ }* c+ @                #nextP = forward4(state[:],isEmpty[:],currP)               
                nextP = forward5(state[:],isEmpty[:],currP)               
                line.append(nextP)
                rgv,currP,t = time_calc([nextP],state,isEmpty,rgv,currP,0)
: s- \- \. C0 |  t" j& j$ S                total += t
9 b! ?. x; m  A5 b                count += 1
                if total>=28800:
" K/ A5 W) R$ W& |) }4 Y" W                        break
# G! j2 j' t3 e        return line
  o! ]) o3 L, f4 |0 I
. U% h6 b6 |, d! x$ Tif __name__ == "__main__":
        state,isEmpty,log,count1,rgv,currP,total,seq = init_first_round()
+ ~3 ?9 u8 B. l        print(state,isEmpty,log,count1,rgv,currP,total,seq)
4 _  J9 v( X/ R5 c* r4 k% D1 Z) J7 ]        line = greedy(state[:],isEmpty[:],rgv,currP,total)
8 h; p; U* j% [( j- c' v! H3 R        simulate(line,state,isEmpty,log,count1,rgv,currP,total)
       
        write_xlsx()
" e# d; w# P! f1 r2 T0 v# R后记

这次博客有点赶，所以质量有点差，很多点没有具体说清楚。主要最近事情比较多。本来也没想写这篇博客，但是觉得人还是要善始善终，虽然没有人来阅读，但是学习的路上还是要多做小结，另外也是万一有需要的朋友也可以给一些参考。虽然我的水平很差劲，但是我希望能够通过交流学习提高更多人包括我自己的水平。不喜勿喷！
( I( L# n- f6 h% B  @! S* h; H---------------------


, ^' d. L, V* d) ?  G6 T: B! p

9 a  o# f6 A) u# M. j
) l& C0 K1 m- d/ n1 I
- A6 U2 V: \4 `* N6 e( @5 n
; T; J" @" |+ i+ Q% C+ @

# T3 |4 {2 G# J  V