用python解决job shop问题

flow shop、job shop和open shop问题区别：

flow shop：如果每个作业需要在每个处理机上加工，而且每个作业的工序也相同，即在处理机上加工的顺序相同，则这种多类机的环境称为同顺序作业或流水作业。

job shop：如果每个作业需要在每个处理机上加工，每个作业有自己的加工顺序，称之为异顺序作业。

open shop：如果每个作业需要在每个处理机上加工，每个作业可按任意顺序加工，称之为自由顺序作业或开放作业。

下面用python来解决job shop问题。

工件的顺序根据(p,q,r)三个指标来确定,p表示该工件当前工序的最早开工时间，q表示后续工序的加工时间，r表示后续工序的个数。（代码用python2实现的，可以在windows的dos环境下运行。）

# -*- coding: utf-8 -*-

import copy

processing_list = [1, 1, 1, 2, 2, 2, 3, 3, 3]
processing_list1 = list(range(9))
machine_list = [1, 2, 3, 1, 3, 2, 2, 1, 5]   # 按工件工序
processing_time = [3, 2, 5, 3, 5, 1, 2, 5, 3]  # 按工件工序

# 求出每道工序的开工时间

initial_start_time = [[]for i in range(len(processing_list))]
initial_start_time[0].append(0)
for i in range(1, len(processing_list)):
    for j in range(0, i):
        if processing_list[j] == processing_list[i]:
            initial_start_time[i].append(processing_time[j])
        else:
            initial_start_time[i].append(0)

for i in range(len(initial_start_time)):
    initial_start_time[i] = sum(initial_start_time[i])


# 求出每个工序的后序工序的加工时间
later_processing_time = [[] for i in range(len(processing_list))]
for i in range(len(processing_list)):
    for j in range(i+1, len(processing_list)):
        if processing_list[j] == processing_list[i]:
            later_processing_time[i].append(processing_time[j])
        else:
            later_processing_time[i].append(0)
for i in range(len(later_processing_time)):
    later_processing_time[i] = sum(later_processing_time[i])

later_process_num = [[] for i in range(len(processing_list))]
for i in range(len(processing_list)):
    for j in range(i+1, len(processing_list)):
        if processing_list[j] == processing_list[i]:
            later_process_num[i].append(1)
        else:
            later_process_num[i].append(0)
for i in range(len(later_process_num)):
    later_process_num[i] = sum(later_process_num[i])

# 工序排序
initial_start_time1 = copy.deepcopy(initial_start_time)
later_processing_time1 = copy.deepcopy(later_processing_time)
later_process_num1 = copy.deepcopy(later_process_num)

# 将（p,q,r）与每个工序对应，用字典表示
list1 = zip(initial_start_time, later_processing_time, later_process_num)
dict1 = {}
for i in range(len(processing_list1)):
    dict1[processing_list1[i]] = list1[i]

#根据冒泡排序法对（p,q,r）中的值依次比较大小，并对工序排序
for i in range(len(processing_list1)):
    for j in range(i+1, len(processing_list1)):
        if dict1[processing_list1[i]][0] > dict1[processing_list1[j]][0]:
            processing_list1[i], processing_list1[j] = processing_list1[j], processing_list1[i]
        elif dict1[processing_list1[i]][0] == dict1[processing_list1[j]][0]:
            if dict1[processing_list1[i]][1] > dict1[processing_list1[j]][1]:
                processing_list1[i], processing_list1[j] = processing_list1[j], processing_list1[i]
            elif dict1[processing_list1[i]][1] == dict1[processing_list1[j]][1]:
                if dict1[processing_list1[j]][2] > dict1[processing_list1[i]][2]:
                    processing_list1[i], processing_list1[j] = processing_list1[j], processing_list1[i]


print '顺序工序:%s'%processing_list1
processing_list2 = []
for i in range(len(processing_list)):
    processing_list2.append(processing_list[processing_list1[i]])
#print list1
print dict1


print '最终工序排序:%s'%processing_list2
#print dict1


# 求出每个工序实际的开工时间以及完工时间
start_time_dict = {}
complete_time_dict = {}
for i in range(len(processing_list1)):
    list1 = [] # 同一个工件每道工序完工时间
    list2 = [] # 同一个机器上所有工序完工时间
    a = 0 # 紧前工序完工时间
    b = 0 # 同一个机器上上一道工序的完工时间
    if i == 0:
        start_time_dict[processing_list1[i]] = 0
        complete_time_dict[processing_list1[i]] = processing_time[processing_list1[i]]
    else:
        for j in range(0, i):
            # 判断当前工序与同一工件前置工序的完工时间和同一个机器上前置工序的完工时间的大小，取两者最大值作为开工时间
            if processing_list2[i] == processing_list2[j]:
                # 是否有紧前工序
                list1.append(complete_time_dict[processing_list1[j]])
            else:
                # 如果没有紧前工序， 判断是否有相同的机器上的前道工序
                list1.append(0)
                if machine_list[processing_list1[i]] == machine_list[processing_list1[j]]:
                    list2.append(complete_time_dict[processing_list1[j]])
                else:
                    list2.append(0)
        a = max(list1)
        b = max(list2)
        start_time_dict[processing_list1[i]] = max(a, b)
        complete_time_dict[processing_list1[i]] = max(a, b) + processing_time[processing_list1[i]]


print start_time_dict

print complete_time_dict