2022年第十四届华中杯数学建模A题解题思路附代码

A 题 分拣系统优化问题

        某电商公司配送中心的工作流程分为统计汇总、转运上架、按订单分拣、核对打包等

步骤。其中，分拣环节操作复杂，耗时较长，其效率是影响配送中心整体性能的关键因素。

首先，系统统计汇总出当天全部待配送订单所包含的所有货品及相应数量。然后，转运工

将这些货品由仓库转运至分拣处，并放置到货架上，等待分拣。上架时，一个货架中仅放

置同一种货品。为简化问题，不考虑货架的容积和载重限制，即每个货架能够放置的货品

件数没有限制。最后，分拣工按任务单依次分拣出每一个订单包含的货品。

 

 

 问题1，基于订单之间的相似度，对所有订单排序，然后在满足N<200的情况下取批次，最终取出的批次有85批。

代码如下：

import pandas as pd
import numpy as np
data=pd.read_csv('D:\Desktop\A题 附件/附件1：订单信息.csv')
Matrix=np.zeros((923,1941),dtype='int') # 每一行代表一个订单，

from tqdm import tqdm
for i in tqdm(range(0,20340)):
    for j in range(1,924):
            if data.iloc[i,0]=='D'+'%04d'%j :
                x=data.iloc[i,1]
                x=x[1:]
                x=int(x)
                Matrix[j-1,x-1]=1
np.savetxt('./Matrix.txt',Matrix,delimiter=' ',fmt='%d')


matrix=np.loadtxt('./Matrix.txt')
list=[]
U=np.zeros((923,923)) 
for i in tqdm(range(0,923)):
    for j in range(0,923):
        x=np.sum(abs(matrix[j]-matrix[i]))
        list.append(x)
        sorted_id = sorted(range(len(list)), key=lambda k: list[k])
    U[i]=np.array(sorted_id)
    list=[]
U=U+1
np.savetxt('./Distance.txt',U,delimiter=' ',fmt='%d')


Matrix=np.loadtxt('./Distance.txt')
list=[1]
k=0
z=1
y=np.zeros((1,1941))
for i in tqdm(range(1000000)):
    x=  Matrix[k][z]
    if x not in list :
        list.append(int(x))             #list直接储存订单
        z=1
    else:
        z=z+1
        if z==923:
            break
        continue
    k=int(x-1)
np.savetxt('./list.txt',list,delimiter=' ',fmt='%d')

 问题2按照蒙特卡洛随机的思想，对每批次内的货品随机排列，并计算距离的最小值，以此作为排列的最优值。

问题3按照指派问题的解决思想，对批次内的订单按距离生成效率矩阵，然后用linear_sum_assignment()函数求解，并分配订单。

问题2和问题3的代码如下：直接一步到位，将结果填入CSV中。

import csv
import random
import copy
import os
import numpy as np
from scipy import optimize
import numpy
import pandas as pd
from tqdm import tqdm


data=pd.read_csv('D:\Desktop\A题 附件/附件1：订单信息.csv')
# print(data)
data=np.array(data)
# 附件1订单名称，按从小到大排列的，每行保存一个订单号
num_order=[]
for i in range(len(data)):
    if data[i][0] not in num_order:
        num_order.append(data[i][0])
# print(len(num_order))
# print(num_order)
# 附件1对应订单的货品信息，每行保存一个订单的所有货品
list_all = []
for i in num_order:
    list_r = []
    for j in range(len(data)):
        if str(i) == str(data[j][0]):
            list_r.append(data[j][1])
    list_all.append(list_r)

# 读取按照相似度排列号的订单顺序
data1=np.loadtxt('./list.txt')
data1=data1-1
listp=[]
list2=[]
list1=[]
# listp保存的每个批次中的订单索引，listp的长度就是分的批次，
# listp的每一行就是批次内的订单索引，对应num_order中的订单编号，
# 即假设listp[0][0]=0,则对应的订单号为num_order[0]='D0001'
for i in range(len(data1)):
    for j in list_all[int(data1[i])]:
        if j not in list2:
            list2.append(j)
    if len(list2)<=200:
        list1.append(int(data1[i]))
    else:
        listp.append(list1)
        list1=[]
        list2=[]
        for j in list_all[int(data1[i])]:
            if j not in list2:
                list2.append(j)
        list1.append(int(data1[i]))

    if i == len(data1)-1:
        list1 = []
        list1.append(int(data1[i]))
        listp.append(list1)



list_aall= []      #     结果2所有的记录，即将这个数据直接写入结果2中
list_3_aall=[]    # 结果3所有的记录，即将这个结果直接写入结果3中
for m in tqdm(range(len(listp))):
    if len(listp[m])==1: # 当批次内只有一个订单时，直接写入结果2和结果3
        # 取批次内货品种类
        number=listp[m][0]
        list_p = []
        for j in list_all[int(number)]:
            if j not in list_p:
                list_p.append(j)
        # print(len(list_p), list_p)
        sorted(list_p)
        # print(list_p)
        list_num = []
        # 货品编号，1-len
        for i in range(len(list_p)):
            list_num.append(i + 1)
        # 直接写入结果2
        list_last_all = []
        for i in range(len(list_p)):
            list_last = []
            list_last.append(list_p[i])
            list_last.append(m + 1)
            list_last.append(i + 1)
            list_last_all.append(list_last)
        for i in list_last_all:
            list_aall.append(i)
        # 直接写入结果3
        list_3=[]
        list_3_all=[]
        list_3.append('D%04d'%(number+1))
        list_3.append(m+1)
        list_3.append(1)
        list_3.append(1)
        list_3_all.append(list_3)
        for i in range(len(list_3_all)):
            list_3_aall.append(list_3_all[i])

        path = './result2.csv'
        f = open(r'{}'.format(path), 'w', encoding='gbk', newline='')
        r1 = csv.writer(f)
        header = ['ItemNo', 'GroupNo', 'ShelfNo']
        r1.writerow(header)
        r1.writerows(list_aall)
        f.close()

        path = './result3.csv'
        f = open(r'{}'.format(path), 'w', encoding='gbk', newline='')
        r1 = csv.writer(f)
        header = ['OrderNo', 'GroupNo', 'WorkerNo', 'TaskNo']
        r1.writerow(header)
        r1.writerows(list_3_aall)
        f.close()

    else:
        # 批次内货品种类
        list_p=[]
        for i in listp[m]:
            for j in list_all[int(i)]:
                if j not in list_p:
                    list_p.append(j)
        # print(len(list_p),list_p)
        sorted(list_p)
        # print(list_p)
        list_num=[]
        for i in range(len(list_p)):
            list_num.append(i+1)
        # 组合成为字典
        vecdict=dict(zip(list_p,list_num))
        # print(vecdict)
        # 将订单货品按字典索引编号，组成向量
        num_all=[]
        for i in listp[m]:
            num_r=[]
            for j in list_all[int(i)]:
                num_r.append(vecdict[j])
            num_all.append(num_r)
        # print(num_all)
        # 将批次内所有货品生成一个货架，并随机货架
        x=[i+1 for i in range(len(list_num))]
        # print(x)
        x_all=[] # 统计所有随机货架信息
        minx_all=[] # 统计每种随机货架下所有订单的距离
        dic_all=[] # 记录每一种货架排列方式下，每个订单的距离
        for i in range(200*200): # 随机200*200次
            np.random.shuffle(x) # 随机货架
            x_all.append(x) # 将货架信息保存
            dic=[] # 记录每个订单的距离
            for p in range(len(num_all)): # 读取批次内货品的长度，即货架的长度
                listx = [] # 记录每个订单内货品在当前货架摆放顺序下得货品索引
                for j in num_all[p]:
                    listx.append(x.index(j)) # 将索引写入
                dicm=max(listx)-min(listx) # 将索引的最大值减去最小值，即为该订单在当前货架排列下的距离
                dic.append(dicm) # 将该订单的距离保存
            dic_all.append(dic)
            # print(dic)
            minx=sum(dic) # 将该批次内所有订单的距离求和并保存
            # print(minx)
            minx_all.append(minx) # 将当前货架摆放顺序下，批次距离保存，即为货架每排列一次，计算一次批次的距离
        # print(min(minx_all)) # 取出批次距离的最小值
        # print(x_all[minx_all.index(min(minx_all))]) # 取出批次距离最小值对应的货架排列顺序
        # 最小距离
        mindic=min(minx_all)
        # 最小距离对应的索引
        minindex=minx_all.index(mindic)
        vecdict=dict((val,key) for key,val in vecdict.items()) # 将货架序号与货品对应
        list_name=[]
        for i in range(len(x_all[minindex])):
            list_name.append(vecdict[x_all[minindex][i]]) # 读取批次距离最小对应的货架排列顺序，并转换为货品种类，即第一个货架存放哪种品类的商品
        # print(list_name)
        path='./result2.csv'
        f=open(r'{}'.format(path),'w',encoding='gbk',newline='')
        r1=csv.writer(f)
        header=['ItemNo','GroupNo','ShelfNo']

        list_last_all=[]
        for i in range(len(list_name)):
            list_last = []
            list_last.append(list_name[i])
            list_last.append(m+1)
            list_last.append(i+1)
            list_last_all.append(list_last)
        for i in list_last_all:
            list_aall.append(i)
        r1.writerow(header)
        r1.writerows(list_aall)
        f.close()


        # 完成一个批次内的订单指派
        # 首先生成指派矩阵
        # 分拣员人数
        n=5
        num=len(listp[m])
        # print('oring len:',num)
        # 补足数量，形成一个N*N的矩阵
        num1=0
        add_num=0
        if num%n!=0:
            add_num=int(num/n)+1
            add_num=int(add_num*n)
        else:add_num=int(num)
        # print(add_num)
        if num<=add_num:
            num1=add_num
        # print(num1,add_num)


        x=copy.deepcopy(dic_all[minindex])
        # print(x)
        # print('dic long', len(x))
        if num