python 寻找优化使成本函数最小的最优解的方法

des_place,src6_place,6:19,8:13,239
src6_place,des_place,6:11,8:31,249
des_place,src6_place,8:04,10:59,136
src6_place,des_place,7:39,10:24,219
des_place,src6_place,9:31,11:43,210
src6_place,des_place,9:15,12:03,99
des_place,src6_place,11:07,13:24,171
src6_place,des_place,11:08,13:07,175
des_place,src6_place,12:31,14:02,234
src6_place,des_place,12:18,14:56,172
des_place,src6_place,14:05,15:47,226
src6_place,des_place,13:37,15:08,250
des_place,src6_place,15:07,17:21,129
src6_place,des_place,15:03,16:42,135
des_place,src6_place,16:35,18:56,144
src6_place,des_place,16:51,19:09,147
des_place,src6_place,18:25,20:34,205
src6_place,des_place,18:12,20:17,242
des_place,src6_place,20:05,21:44,172
src6_place,des_place,20:05,22:06,261
des_place,src5_place,6:03,8:43,219
src5_place,des_place,6:05,8:32,174
des_place,src5_place,7:50,10:08,164
src5_place,des_place,8:25,10:34,157
des_place,src5_place,9:11,10:42,172
src5_place,des_place,9:42,11:32,169
des_place,src5_place,10:33,13:11,132
src5_place,des_place,11:01,12:39,260
des_place,src5_place,12:08,14:47,231
src5_place,des_place,12:44,14:17,134
des_place,src5_place,14:19,17:09,190
src5_place,des_place,14:22,16:32,126
des_place,src5_place,15:04,17:23,189
src5_place,des_place,15:58,18:40,173
des_place,src5_place,17:06,20:00,95
src5_place,des_place,16:43,19:00,246
des_place,src5_place,18:33,20:22,143
src5_place,des_place,18:48,21:45,246
des_place,src5_place,19:32,21:25,160
src5_place,des_place,19:50,22:24,269
des_place,src4_place,6:33,9:14,172
src4_place,des_place,6:25,9:30,335
des_place,src4_place,8:23,11:07,143
src4_place,des_place,7:34,9:40,324
des_place,src4_place,9:25,12:46,295
src4_place,des_place,9:15,12:29,225
des_place,src4_place,11:08,14:38,262
src4_place,des_place,11:28,14:40,248
des_place,src4_place,12:37,15:05,170
src4_place,des_place,12:05,15:30,330
des_place,src4_place,14:08,16:09,232
src4_place,des_place,14:01,17:24,338
des_place,src4_place,15:23,18:49,150
src4_place,des_place,15:34,18:11,326
des_place,src4_place,16:50,19:26,304
src4_place,des_place,17:07,20:04,291
des_place,src4_place,18:07,21:30,355
src4_place,des_place,18:23,21:35,134
des_place,src4_place,20:27,23:42,169
src4_place,des_place,19:53,22:21,173
des_place,src1_place,6:39,8:09,86
src1_place,des_place,6:17,8:26,89
des_place,src1_place,8:23,10:28,149
src1_place,des_place,8:04,10:11,95
des_place,src1_place,9:58,11:18,130
src1_place,des_place,9:45,11:50,172
des_place,src1_place,10:33,12:03,74
src1_place,des_place,11:16,13:29,83
des_place,src1_place,12:08,14:05,142
src1_place,des_place,12:34,15:02,109
des_place,src1_place,13:39,15:30,74
src1_place,des_place,13:40,15:37,138
des_place,src1_place,15:25,16:58,62
src1_place,des_place,15:27,17:18,151
des_place,src1_place,17:03,18:03,103
src1_place,des_place,17:11,18:30,108
des_place,src1_place,18:24,20:49,124
src1_place,des_place,18:34,19:36,136
des_place,src1_place,19:58,21:23,142
src1_place,des_place,20:17,22:22,102
des_place,src2_place,6:09,9:49,414
src2_place,des_place,6:12,10:22,230
des_place,src2_place,7:57,11:15,347
src2_place,des_place,7:53,11:37,433
des_place,src2_place,9:49,13:51,229
src2_place,des_place,9:08,12:12,364
des_place,src2_place,10:51,14:16,256
src2_place,des_place,10:30,14:57,290
des_place,src2_place,12:20,16:34,500
src2_place,des_place,12:19,15:25,342
des_place,src2_place,14:20,17:32,332
src2_place,des_place,13:54,18:02,294
des_place,src2_place,15:49,20:10,497
src2_place,des_place,15:44,18:55,382
des_place,src2_place,17:14,20:59,277
src2_place,des_place,16:52,20:48,448
des_place,src2_place,18:44,22:42,351
src2_place,des_place,18:26,21:29,464
des_place,src2_place,19:57,23:15,512
src2_place,des_place,20:07,23:27,473
des_place,src3_place,6:58,9:01,238
src3_place,des_place,6:08,8:06,224
des_place,src3_place,8:19,11:16,122
src3_place,des_place,8:27,10:45,139
des_place,src3_place,9:58,12:56,249
src3_place,des_place,9:15,12:14,247
des_place,src3_place,10:32,13:16,139
src3_place,des_place,10:53,13:36,189
des_place,src3_place,12:01,13:41,267
src3_place,des_place,12:08,14:59,149
des_place,src3_place,13:37,15:33,142
src3_place,des_place,13:40,15:38,137
des_place,src3_place,15:50,18:45,243
src3_place,des_place,15:23,17:25,232
des_place,src3_place,16:33,18:15,253
src3_place,des_place,17:08,19:08,262
des_place,src3_place,18:17,21:04,259
src3_place,des_place,18:35,20:28,204
des_place,src3_place,19:46,21:45,214
src3_place,des_place,20:30,23:11,114

# 人员的名称和来源地信息
peoplelist = [('name1','src1_place'),
       ('name2','src2_place'),
       ('name3','src3_place'),
       ('name4','src4_place'),
       ('name5','src5_place'),
       ('name6','src6_place')]
# 目的机场
destination='des_place'

flights={} #加载所有航班信息。
# 查询所有的航班信息
for line in open('schedule.txt'):
  origin,dest,depart,arrive,price=line.strip().split(',') #源地址、目的地址、离开时间、到达时间、价格
  flights.setdefault((origin,dest),[])  #航班信息已起止点为键值，每个起止点有多个航班

  # 将航班信息添加到航班列表中
  flights[(origin,dest)].append((depart,arrive,int(price))) #按时间顺序扩展每次航班

# 将数字序列转换为航班，打印输出。输入为数字序列
def printschedule(r):
  for d in range(int(len(r)/2)):
    name=peoplelist[d][0]  #人员名称
    origin=peoplelist[d][1] #人员来源地
    out=flights[(origin,destination)][int(r[2*d])] #往程航班
    ret=flights[(destination,origin)][int(r[2*d+1])] #返程航班
    print('%10s %10s %5s-%5s $%3s %5s-%5s $%3s' % (name,origin,out[0],out[1],out[2],ret[0],ret[1],ret[2]))

# 计算某个给定时间在一天中的分钟数
def getminutes(t):
  x = time.strptime(t, '%H:%M')
  return x[3] * 60 + x[4]

# 成本函数。输入为数字序列
def schedulecost(sol):
  totalprice=0
  latestarrival=0
  earliestdep=24*60
  for d in range(int(len(sol)/2)):
    # 得到往返航班
    origin=peoplelist[d][1] #获取人员的来源地
    outbound=flights[(origin,destination)][int(sol[2*d])] #获取往程航班
    returnf=flights[(destination,origin)][int(sol[2*d+1])] #获取返程航班

    # 总价格等于所有往返航班的价格之和
    totalprice+=outbound[2]
    totalprice+=returnf[2]

    # 记录最晚到达和最早离开的时间
    if latestarrival<getminutes(outbound[1]): latestarrival=getminutes(outbound[1])
    if earliestdep>getminutes(returnf[0]): earliestdep=getminutes(returnf[0])

  # 接机服务：每个人必须在机场等待直到最后一个人到达位置
  # 送机服务：他们必须同时达到机场，并等待他们的返程航班
  totalwait=0
  for d in range(int(len(sol)/2)):
    origin=peoplelist[d][1]
    outbound=flights[(origin,destination)][int(sol[2*d])]
    returnf=flights[(destination,origin)][int(sol[2*d+1])]
    totalwait+=latestarrival-getminutes(outbound[1])
    totalwait+=getminutes(returnf[0])-earliestdep

    # 这个题解要求多付一天的汽车出租费用么？如果是，则费用为50美元
  if latestarrival>earliestdep: totalprice+=50

  return totalprice+totalwait

def randomoptimize(domain,costf):
  best=999999999
  bestr=None
  for i in range(0,1000):
    # 创建随机解
    sol=[random.randint(domain[i][0],domain[i][1]) for i in range(len(domain))]
    #计算成本值
    cost=costf(sol)

    # 与目前得到的最优解进行比较
    if cost<best:
      best=cost
      bestr=sol
  return sol #返回随机最优解

def hillclimb(domain,costf):
  # 创建一个随机解
  sol=[random.randint(domain[i][0],domain[i][1]) for i in range(len(domain))]
  # 主循环
  while 1:
    # 创建相邻解的列表
    neighbors=[]

    for j in range(len(domain)):  #在j等于0和末尾的时候存在问题
      # 在每个方向上相对于原值偏离一点。每个方向上的偏离不相互影响
      if sol[j]>domain[j][0]:
        neighbors.append(sol[0:j]+[sol[j]-1]+sol[j+1:]) #向近0偏移
      if sol[j]<domain[j][1]:
        neighbors.append(sol[0:j]+[sol[j]+1]+sol[j+1:]) #远0偏移

    # 在相邻解中寻找最优解
    current=costf(sol)
    best=current
    for j in range(len(neighbors)):
      cost=costf(neighbors[j])
      if cost<best:
        best=cost
        sol=neighbors[j]

    # 如果没有更好的解，则退出循环。即寻找了极低点
    if best==current:
      break
  return sol

def annealingoptimize(domain,costf,T=10000.0,cool=0.95,step=1):
  # 随机初始化值
  vec=[float(random.randint(domain[i][0],domain[i][1])) for i in range(len(domain))]

  while T>0.1:
    # 选择一个索引值
    i=random.randint(0,len(domain)-1)

    # 选择一个改变索引值的方向
    dir=random.randint(-step,step)

    #创建一个代表题解的新列表，改变其中一个值
    vecb=vec[:]
    vecb[i]+=dir
    if vecb[i]<domain[i][0]: vecb[i]=domain[i][0]  #如果渐变不超出了题解的范围
    elif vecb[i]>domain[i][1]: vecb[i]=domain[i][1] #如果渐变不超出了题解的范围

    # 计算当前成本与新的成本
    ea=costf(vec)
    eb=costf(vecb)
    p=pow(math.e,(-eb-ea)/T)

    # 它是更好的解么？或者是趋向最优解的可能的临界解么
    if (eb<ea or random.random()<p):
      vec=vecb

      # 降低温度
    T=T*cool
  return vec

def geneticoptimize(domain,costf,popsize=50,step=1,mutprob=0.2,elite=0.2,maxiter=100):
  # 变异操作，存在变异失败的情况
  def mutate(vec):
    i=random.randint(0,len(domain)-1)
    if random.random()<0.5 and vec[i]>=domain[i][0]+step:
      return vec[0:i]+[vec[i]-step]+vec[i+1:]
    elif vec[i]<=domain[i][1]-step:
      return vec[0:i]+[vec[i]+step]+vec[i+1:]

  # 杂交操作（交叉）
  def crossover(r1,r2):
    i=random.randint(1,len(domain)-2)
    return r1[0:i]+r2[i:]

  # 构建初始种群
  pop=[]
  for i in range(popsize):  #随机产生50个动物的种群
    vec=[random.randint(domain[i][0],domain[i][1]) for i in range(len(domain))]
    pop.append(vec)
  # 每一代有多少胜出者？
  topelite=int(elite*popsize)

  # 主循环
  for i in range(maxiter):
    scores=[(costf(v),v) for v in pop]
    scores.sort()
    ranked=[v for (s,v) in scores]

    # 在种群中选出优胜者
    pop=ranked[0:topelite]

    # 为优秀基因者，添加变异和配对后的胜出者
    while len(pop)<popsize:
      if random.random()<mutprob:  #变异所占的比例

        # 变异
        c=random.randint(0,topelite-1)
        newanimal = mutate(ranked[c])
        if newanimal!=None:  #有可能存在变异死亡者
          pop.append(newanimal)
      else:

        # 相互杂交。以后会遇到近亲结婚的问题
        c1=random.randint(0,topelite-1)
        c2=random.randint(0,topelite-1)
        newanimal = crossover(ranked[c1], ranked[c2])
        pop.append(newanimal)

    # 打印当前最优解和成本
    # print(scores[0])
  return scores[0][1] #返回最优解

if __name__=="__main__":   #只有在执行当前模块时才会运行此函数
  print(flights)  #打印所有航班信息
  domain=[]
  for start_stop in flights:       #查询每个起止点的航班个数
    domain.append((0,len(flights[start_stop])-1))  #获取题解范围，两边必区间（航班范围的数据序列）

  # domain=[(0,9)]*(len(peoplelist)*2)
  print(domain)
  s=randomoptimize(domain,schedulecost) # 随机搜索法，寻找最优题解
  print(s)
  printschedule(s) #打印最优航班信息
  s = hillclimb(domain, schedulecost) # 爬山法，寻找最优题解
  print(s)
  printschedule(s) # 打印最优航班信息
  s = annealingoptimize(domain, schedulecost) # 模拟退火算法，寻找最优题解
  print(s)
  printschedule(s) # 打印最优航班信息
  s = geneticoptimize(domain, schedulecost) # 遗传算法，寻找最优题解
  print(s)
  printschedule(s) # 打印最优航班信息

# 优化算法。寻找使成本函数最小的题解。
import time
import random
import math
# 问题场景：
# 所有乘客从不同的地方飞到同一个目的地，服务人员等待所有人到来以后将人一次性接走。
# 离开时，服务人员将人一次性带到飞机场，所有乘客等待自己的航班离开。
# 要解决的问题：
# 如何设置乘客的到来和离开航班，以及接送机的时间，使得总代价最小。
# 将题解设为数字序列。
# 数字表示某人乘坐的第几次航班，从0开始，例如[1,4,3,2,7,3,6,3,2]表示第1个人做第2个航班来，第5个航班走，第2个人做第4个航班来，第3个航班走
# 题解相互独立：组团旅游问题，举办会议的人员接送问题
# 人员的名称和来源地信息
peoplelist = [('name1','src1_place'),
       ('name2','src2_place'),
       ('name3','src3_place'),
       ('name4','src4_place'),
       ('name5','src5_place'),
       ('name6','src6_place')]
# 目的机场
destination='des_place'

flights={} #加载所有航班信息。
# 查询所有的航班信息
for line in open('schedule.txt'):
  origin,dest,depart,arrive,price=line.strip().split(',') #源地址、目的地址、离开时间、到达时间、价格
  flights.setdefault((origin,dest),[])  #航班信息已起止点为键值，每个起止点有多个航班

  # 将航班信息添加到航班列表中
  flights[(origin,dest)].append((depart,arrive,int(price))) #按时间顺序扩展每次航班

# 将数字序列转换为航班，打印输出。输入为数字序列
def printschedule(r):
  for d in range(int(len(r)/2)):
    name=peoplelist[d][0]  #人员名称
    origin=peoplelist[d][1] #人员来源地
    out=flights[(origin,destination)][int(r[2*d])] #往程航班
    ret=flights[(destination,origin)][int(r[2*d+1])] #返程航班
    print('%10s %10s %5s-%5s $%3s %5s-%5s $%3s' % (name,origin,out[0],out[1],out[2],ret[0],ret[1],ret[2]))

# 计算某个给定时间在一天中的分钟数
def getminutes(t):
  x = time.strptime(t, '%H:%M')
  return x[3] * 60 + x[4]

# 成本函数。输入为数字序列
def schedulecost(sol):
  totalprice=0
  latestarrival=0
  earliestdep=24*60
  for d in range(int(len(sol)/2)):
    # 得到往返航班
    origin=peoplelist[d][1] #获取人员的来源地
    outbound=flights[(origin,destination)][int(sol[2*d])] #获取往程航班
    returnf=flights[(destination,origin)][int(sol[2*d+1])] #获取返程航班

    # 总价格等于所有往返航班的价格之和
    totalprice+=outbound[2]
    totalprice+=returnf[2]

    # 记录最晚到达和最早离开的时间
    if latestarrival<getminutes(outbound[1]): latestarrival=getminutes(outbound[1])
    if earliestdep>getminutes(returnf[0]): earliestdep=getminutes(returnf[0])

  # 接机服务：每个人必须在机场等待直到最后一个人到达位置
  # 送机服务：他们必须同时达到机场，并等待他们的返程航班
  totalwait=0
  for d in range(int(len(sol)/2)):
    origin=peoplelist[d][1]
    outbound=flights[(origin,destination)][int(sol[2*d])]
    returnf=flights[(destination,origin)][int(sol[2*d+1])]
    totalwait+=latestarrival-getminutes(outbound[1])
    totalwait+=getminutes(returnf[0])-earliestdep

    # 这个题解要求多付一天的汽车出租费用么？如果是，则费用为50美元
  if latestarrival>earliestdep: totalprice+=50

  return totalprice+totalwait

# 随机搜索算法：随机选择题解，计算成本值，成本值最小的题解为确定题解。domain为题解范围（可选航班范围），costf为成本函数。
def randomoptimize(domain,costf):
  best=999999999
  bestr=None
  for i in range(0,1000):
    # 创建随机解
    sol=[random.randint(domain[i][0],domain[i][1]) for i in range(len(domain))]
    #计算成本值
    cost=costf(sol)

    # 与目前得到的最优解进行比较
    if cost<best:
      best=cost
      bestr=sol
  return sol #返回随机最优解


# 爬山法：对于成本函数连续的情况，题解向成本值减小的地方渐变，直到成本值不再变化。domain为题解范围（可选航班范围），costf为成本函数。
# 在只有一个极低点时最有效。可以采用随机重复爬山法优化
def hillclimb(domain,costf):
  # 创建一个随机解
  sol=[random.randint(domain[i][0],domain[i][1]) for i in range(len(domain))]
  # 主循环
  while 1:
    # 创建相邻解的列表
    neighbors=[]

    for j in range(len(domain)):  #在j等于0和末尾的时候存在问题
      # 在每个方向上相对于原值偏离一点。每个方向上的偏离不相互影响
      if sol[j]>domain[j][0]:
        neighbors.append(sol[0:j]+[sol[j]-1]+sol[j+1:]) #向近0偏移
      if sol[j]<domain[j][1]:
        neighbors.append(sol[0:j]+[sol[j]+1]+sol[j+1:]) #远0偏移

    # 在相邻解中寻找最优解
    current=costf(sol)
    best=current
    for j in range(len(neighbors)):
      cost=costf(neighbors[j])
      if cost<best:
        best=cost
        sol=neighbors[j]

    # 如果没有更好的解，则退出循环。即寻找了极低点
    if best==current:
      break
  return sol

# 模拟退火算法：概率性接收更优解（更差解），时间越久，概率越大（越低）。
def annealingoptimize(domain,costf,T=10000.0,cool=0.95,step=1):
  # 随机初始化值
  vec=[float(random.randint(domain[i][0],domain[i][1])) for i in range(len(domain))]
  while T>0.1:
    # 选择一个索引值
    i=random.randint(0,len(domain)-1)

    # 选择一个改变索引值的方向
    dir=random.randint(-step,step)

    #创建一个代表题解的新列表，改变其中一个值
    vecb=vec[:]
    vecb[i]+=dir
    if vecb[i]<domain[i][0]: vecb[i]=domain[i][0]  #如果渐变不超出了题解的范围
    elif vecb[i]>domain[i][1]: vecb[i]=domain[i][1] #如果渐变不超出了题解的范围

    # 计算当前成本与新的成本
    ea=costf(vec)
    eb=costf(vecb)
    p=pow(math.e,(-eb-ea)/T)

    # 它是更好的解么？或者是趋向最优解的可能的临界解么
    if (eb<ea or random.random()<p):
      vec=vecb

      # 降低温度
    T=T*cool
  return vec

# 遗传算法：基因杂交（交叉）或基因变异。domain题解范围，costf成本函数，popsize种群大小，step变异基因量，mutprob变异比例，elite优秀基因者的比例，maxiter运行多少代
def geneticoptimize(domain,costf,popsize=50,step=1,mutprob=0.2,elite=0.2,maxiter=100):
  # 变异操作，存在变异失败的情况
  def mutate(vec):
    i=random.randint(0,len(domain)-1)
    if random.random()<0.5 and vec[i]>=domain[i][0]+step:
      return vec[0:i]+[vec[i]-step]+vec[i+1:]
    elif vec[i]<=domain[i][1]-step:
      return vec[0:i]+[vec[i]+step]+vec[i+1:]

  # 杂交操作（交叉）
  def crossover(r1,r2):
    i=random.randint(1,len(domain)-2)
    return r1[0:i]+r2[i:]

  # 构建初始种群
  pop=[]
  for i in range(popsize):  #随机产生50个动物的种群
    vec=[random.randint(domain[i][0],domain[i][1]) for i in range(len(domain))]
    pop.append(vec)
  # 每一代有多少胜出者？
  topelite=int(elite*popsize)

  # 主循环
  for i in range(maxiter):
    scores=[(costf(v),v) for v in pop]
    scores.sort()
    ranked=[v for (s,v) in scores]

    # 在种群中选出优胜者
    pop=ranked[0:topelite]

    # 为优秀基因者，添加变异和配对后的胜出者
    while len(pop)<popsize:
      if random.random()<mutprob:  #变异所占的比例

        # 变异
        c=random.randint(0,topelite-1)
        newanimal = mutate(ranked[c])
        if newanimal!=None:  #有可能存在变异死亡者
          pop.append(newanimal)
      else:

        # 相互杂交。以后会遇到近亲结婚的问题
        c1=random.randint(0,topelite-1)
        c2=random.randint(0,topelite-1)
        newanimal = crossover(ranked[c1], ranked[c2])
        pop.append(newanimal)

    # 打印当前最优解和成本
    # print(scores[0])
  return scores[0][1] #返回最优解

if __name__=="__main__":   #只有在执行当前模块时才会运行此函数
  print(flights)  #打印所有航班信息
  domain=[]
  for start_stop in flights:       #查询每个起止点的航班个数
    domain.append((0,len(flights[start_stop])-1))  #获取题解范围，两边必区间（航班范围的数据序列）

  # domain=[(0,9)]*(len(peoplelist)*2)
  print(domain)
  s=randomoptimize(domain,schedulecost) # 随机搜索法，寻找最优题解
  print(s)
  printschedule(s) #打印最优航班信息
  s = hillclimb(domain, schedulecost) # 爬山法，寻找最优题解
  print(s)
  printschedule(s) # 打印最优航班信息
  s = annealingoptimize(domain, schedulecost) # 模拟退火算法，寻找最优题解
  print(s)
  printschedule(s) # 打印最优航班信息
  s = geneticoptimize(domain, schedulecost) # 遗传算法，寻找最优题解
  print(s)
  printschedule(s) # 打印最优航班信息

# 利用之前设计好的优化算法，解决涉及偏好的优化问题。1、将题解转化为数字序列化，可以写出题解范围。2、成本函数能返回值
import random
import math
import optimization

# 场景：每个房间有两个床位，每个学生有自己首选房间和次选房间（只选房间，不选床位）。将所有学生安排到所有房间
# 目标：在尽量满足学生的选择的情况下，为学生安排宿舍

# 将题解转化为数字间没有联系的数字序列。可以让每个数字代表可选床位的第几个，索引从0开始
# 例如：[0,2,1,1,1,2,0,1]表示第1个人选可选床位的第1个，第2个人选剩余可选床位的第3个床位，第3个人选剩余可选床位的第2个。。。

# 代表宿舍，每个宿舍有两个床位。5个房间
dorms=['Zeus','Athena','Hercules','Bacchus','Pluto']

# 代表学生及其首选房间和次选房间。10个人
prefs=[('Toby', ('Bacchus', 'Hercules')),
    ('Steve', ('Zeus', 'Pluto')),
    ('Karen', ('Athena', 'Zeus')),
    ('Sarah', ('Zeus', 'Pluto')),
    ('Dave', ('Athena', 'Bacchus')), 
    ('Jeff', ('Hercules', 'Pluto')), 
    ('Fred', ('Pluto', 'Athena')), 
    ('Suzie', ('Bacchus', 'Hercules')), 
    ('Laura', ('Bacchus', 'Hercules')), 
    ('James', ('Hercules', 'Athena'))]

# [(0,9),(0,8),(0,7),(0,6),...,(0,0)]  题解范围。因为前面选择了一个，后面的可选范围就会变少
domain=[(0,(len(dorms)*2)-i-1) for i in range(0,len(dorms)*2)]  #题解的可选范围


# 打印输出题解。输入为题解序列
def printsolution(vec):
 slots=[]
 # 为每个宿舍键两个槽
 for i in range(len(dorms)): slots+=[i,i]

 # 遍历每一名学生的安置情况
 for i in range(len(vec)):
  x=int(vec[i])

  # 从剩余槽中选择
  dorm=dorms[slots[x]]
  # 输出学生及其被分配的宿舍
  print(prefs[i][0],dorm)
  # 删除该槽，这样后面的数字列表才能正确翻译成“剩余床位”
  del slots[x]

# 成本函数：
def dormcost(vec):
 cost=0
 # 创建一个槽序列
 slots=[0,0,1,1,2,2,3,3,4,4]

 # 遍历每一名学生
 for i in range(len(vec)):
  x=int(vec[i])
  dorm=dorms[slots[x]]
  pref=prefs[i][1]
  # 首选成本值为0，次选成本值为1
  if pref[0]==dorm: cost+=0
  elif pref[1]==dorm: cost+=1
  else: cost+=3
  # 不在选择之列则成本值为3

  # 删除选中的槽
  del slots[x]

 return cost

if __name__=="__main__":   #只有在执行当前模块时才会运行此函数
  print(domain)
  s = optimization.randomoptimize(domain, dormcost) # 随机搜索法，寻找最优题解
  print(s)
  printsolution(s) # 打印最优解代表的含义
  s = optimization.hillclimb(domain, dormcost) # 爬山法，寻找最优题解
  print(s)
  printsolution(s) # 打印最优解代表的含义
  s = optimization.annealingoptimize(domain, dormcost) # 模拟退火算法，寻找最优题解
  print(s)
  printsolution(s) # 打印最优解代表的含义
  s = optimization.geneticoptimize(domain, dormcost) # 遗传算法，寻找最优题解
  print(s)
  printsolution(s) # 打印最优解代表的含义

# 将优化算法应用到绘制关系网图中，使得交叉线最少
import math
import optimization
# 场景：在绘制关系网图中，每个人在图中都有位置x，y坐标，在有关联的两个人中间添加连线。
# 目标：是所有连线的交叉数最少
# 将题解转化为数字间没有联系的数字序列。可以让每个数字代表人物在图形中的位置x，y
# 例如：[200,120,250,230..]表示第1个人坐标为200,120，第2个人坐标为250,230...
# 关系网中涉及的人员
people=['Charlie','Augustus','Veruca','Violet','Mike','Joe','Willy','Miranda']

# 关联关系
links=[('Augustus', 'Willy'), 
    ('Mike', 'Joe'), 
    ('Miranda', 'Mike'), 
    ('Violet', 'Augustus'), 
    ('Miranda', 'Willy'), 
    ('Charlie', 'Mike'), 
    ('Veruca', 'Joe'), 
    ('Miranda', 'Augustus'), 
    ('Willy', 'Augustus'), 
    ('Joe', 'Charlie'), 
    ('Veruca', 'Augustus'), 
    ('Miranda', 'Joe')]

# 计算交叉线，作为成本函数
def crosscount(v):
 # 将数字序列转化为一个person:(x,y)的字典
 loc=dict([(people[i],(v[i*2],v[i*2+1])) for i in range(0,len(people))])
 total=0

 # 遍历每一对连线
 for i in range(len(links)):
  for j in range(i+1,len(links)):

   # 获取坐标位置
   (x1,y1),(x2,y2)=loc[links[i][0]],loc[links[i][1]]
   (x3,y3),(x4,y4)=loc[links[j][0]],loc[links[j][1]]

   den=(y4-y3)*(x2-x1)-(x4-x3)*(y2-y1)

   # 如果两线平行，则den==0。两条线是线段，不是直线
   if den==0: continue

   # 否则，ua与ub就是两条交叉线的分数值。
   # line where they cross
   ua=((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3))/den
   ub=((x2-x1)*(y1-y3)-(y2-y1)*(x1-x3))/den

   # 如果两条线的分数值介于0和1之间，则两线彼此交叉
   if ua>0 and ua<1 and ub>0 and ub<1:
    total+=1
  for i in range(len(people)):
   for j in range(i+1,len(people)):
    # 获取两个节点的位置
    (x1,y1),(x2,y2)=loc[people[i]],loc[people[j]]

    # 获取两节点之间的距离
    dist=math.sqrt(math.pow(x1-x2,2)+math.pow(y1-y2,2))
    # 对间距小于50个像素的节点进行判罚
    if dist<50:
     total+=(1.0-(dist/50.0))

 return total
#画图，绘制网络
from PIL import Image,ImageDraw

def drawnetwork(sol):
 # 建立image对象
 img=Image.new('RGB',(400,400),(255,255,255))
 draw=ImageDraw.Draw(img)

 # 建立标识位置信息的字典
 pos=dict([(people[i],(sol[i*2],sol[i*2+1])) for i in range(0,len(people))])
 for (a,b) in links:
  draw.line((pos[a],pos[b]),fill=(255,0,0))
 for n,p in pos.items():
  draw.text(p,n,(0,0,0))
 img.show()
domain=[(10,370)]*(len(people)*2) #设定题解范围
if __name__=="__main__":   #只有在执行当前模块时才会运行此函数
  print(domain)
  s = optimization.randomoptimize(domain, crosscount) # 随机搜索法，寻找最优题解
  print(s)
  drawnetwork(s) # 绘制关系网
  s = optimization.hillclimb(domain, crosscount) # 爬山法，寻找最优题解
  print(s)
  drawnetwork(s) # 绘制关系网
  s = optimization.annealingoptimize(domain, crosscount) # 模拟退火算法，寻找最优题解
  print(s)
  drawnetwork(s) # 绘制关系网
  s = optimization.geneticoptimize(domain, crosscount) # 遗传算法，寻找最优题解
  print(s)
  drawnetwork(s) # 绘制关系网