最优解问题：婚礼来宾座位安排

@最优解问题：婚礼来宾座位安排

问题描述

有一对年轻人即将举行婚礼，他们想要合理的安排参加婚礼的客人的座位，要求朋友之间要坐在一起，关系不好的（敌人）要分开坐，针对这个问题，给出安排的方案。结合现实分析，很明显，这个问题存在的最优解非常多，要把所有的最优解都求出来较为麻烦且没有必要。我们只要给出满足条件的少数几个最优解即可

求解思路

对安排座位的过程进行模拟，有以下规则：

1. 将甲安排到A桌时，如果A桌有甲的一个朋友（多个则叠加），则预测A桌的关系指数 +2
2. 将甲安排到A桌时，如果A桌没有甲的朋友，则预测A桌的关系指数 +0
3. 将甲安排到A桌时，如果A桌有甲的一个敌人（多个则叠加），则预测A桌的关系指数 -1
4. 每一次安排都让总的关系指数增加最大的值，且最大值不能小于0

代码

假设宾客之间的关系是这样的（数据量小，方便和结果对比）：

# -*- coding:utf-8 -*-
# author：jxjxjjxjxjxj
# 基本思路：模拟————————朋友相遇：2；敌人相遇：-1；其他：0 ,关系指数等于最大值即为最优解
from openpyxl import load_workbook
import copy
import random


# 定义桌子,一张桌子最多可以坐self.numbers 个人
class Table:
    def __init__(self):
        self.numbers = 4  # 指定了一张桌子可以坐4个人，可根据实际修改，
        self.relationship = 0
        self.guests = []
        self.score = 0  # 保存上一次调用函数计算出的成员添加分数，减少重复计算

    #预测安排这一个客人后关系指数的变化值并返回
    def get_score(self, guest):
        result = 0
        if len(self.guests) == 0:
            pass
        elif len(self.guests) >= self.numbers:
            result = -1
        else:
            for i in self.guests:
                if self.add(i, guest) >= 0:
                    result += self.add(i, guest)
                else:
                    result = -1
        self.score = result
        return result

    def addGuest(self, guest):
        self.relationship += self.score
        self.guests.append(guest)

    #预测两个客人被安排在同一桌，关系指数会产生的变化
    def add(self, guest_1, guest_2):
        if guest_1['Guests'] in guest_2['Friends']:
            result = 2
        elif guest_1['Guests'] in guest_2['Enemies']:
            result = -1
        else:
            result = 0
        return result


# 定义一个方案，一个方案由多个Table组成
class Tables:
    def __init__(self):
        self.tables = []
        self.tables.append(Table())
        self.guest = 0  # 保留上一次调用函数要添加的宾客（但是还没添加）

    def add_table(self):
        table = Table()
        self.tables.append(table)

    def get_relationship(self):
        relationship = 0
        for table in self.tables:
            relationship += table.relationship
        return relationship

    #返回字典，字典中包含将一个客人添加到一个方案中，可以让关系指数增加最多的几种添加方案（可以是-1）
    def get_score(self, guest):
        self.guest = guest
        scores = {}
        new_scores = {}
        for i in range(len(self.tables)):
            score = self.tables[i].get_score(guest)
            scores[i] = score
        score_max = max(scores.values())
        for i in scores:
            if scores[i] == score_max:
                new_scores[i] = score_max
        return new_scores

    def addGuest(self, i):  # i 表示对第几张桌子进行添加客人
        self.tables[i].addGuest(self.guest)


# Test类生成模拟方案
class Test:
    def __init__(self, guests):
        self.schedules = []
        self.guests = guests
        self.schedules.append(Tables())

    def addSchedule(self, schedule):
        self.schedules.append(schedule)

    # 专门进行scores字典的处理
    def score_analysis(self, schedule, scores):
        if len(scores.values()) == 1 and list(scores.values())[0] > -1:
            schedule.addGuest(list(scores.keys())[0])
        elif list(scores.values())[0] == -1:
            schedule.add_table()
            schedule.addGuest(len(schedule.tables) - 1)
        #score字典中包含了多种添加方式，在原有的方案基础之上创建新的方案，对每一个方案采用不同的添加方式
        else:
            schedule.addGuest(list(scores.keys())[0])
            del scores[list(scores.keys())[0]]
            for i in scores:
                new_schedule = copy.deepcopy(schedule)
                new_schedule.addGuest(i)
                self.addSchedule(new_schedule)

    def run(self):
        for guest in self.guests:
            for schedule in self.schedules:
                scores = schedule.get_score(guest)
                self.score_analysis(schedule, scores)

    def show_schedule(self):
        i = 1
        for schedule in self.schedules:
            print("————————第{}种分配方案,共需要{}安排桌,关系指数：{}——————————".format(i, len(schedule.tables),
                                                                       schedule.get_relationship()))
            i += 1
            for table in schedule.tables:
                print(table.guests)


def main():
    # 读取数据
    wb = load_workbook('C:\\Users\\Administrator\\Desktop\\婚礼宾客关系表.xlsx')
    ws = wb.active
    content_list = []
    for col in ws.iter_cols(min_row=1, max_col=3, values_only=True):
        content_list.append(list(col))

    # 求出最优解对应的relationship_index的值
    friends = ",".join(content_list[1][1:]).split(",") # 表格中出现的多个人名使用英文","分隔
    relationship_index = 0
    for i in friends:
        if i != '-':
            relationship_index += 1

    #将宾客信息保存在guests列表里面
    for i in range(len(content_list)):
        for j in range(len(content_list[0])):
            if ',' in content_list[i][j]:
                content_list[i][j] = content_list[i][j].split(',')
    guests = []
    for i in range(1, len(content_list[0])):
        guest = {}
        guest[content_list[0][0]] = content_list[0][i]
        guest[content_list[1][0]] = content_list[1][i]
        guest[content_list[2][0]] = content_list[2][i]
        guests.append(guest)
    # 进行模拟分配方案，分配结果与表格中人名的先后顺序有关，一般经过少数几次模拟即可得出一个或几个最优解
    print("*" * 100)
    print("该方案的关系指数最优值等于：{}".format(relationship_index))
    for i in range(5):  # 进行5次模拟分配，如果希望得到更多的解，可增加模拟次数
        print("***************第{}次模拟*******************\n".format(i + 1))
        random.shuffle(guests)
        test = Test(guests)
        test.run()
        test.show_schedule()


main()

模拟生成的方案

程序模拟生成的结果与guests列表中宾客的顺序有关，我们进行了5次模拟，假设一张桌子可以坐4个人，每一次模拟时guests中的宾客都有不同的顺序，我们可以得到很多的解，在不考虑桌子数量限制的情况下，关系指数等于最优值的就是最优解（代码中没有过滤不是最优解的分配方案）

下面是模拟结果的一部分

****************************************************************************************************
该方案的关系指数最优值等于：6
***************第1次模拟*******************

————————第1种分配方案,共需要2安排桌,关系指数：6——————————
[{'Guests': 'Cersei', 'Friends': 'Jaime', 'Enemies': ['Danerys', 'Sansa']}, {'Guests': 'Beth', 'Friends': 'Tyrion', 'Enemies': '-'}, {'Guests': 'Jaime', 'Friends': 'Cersei', 'Enemies': 'Jon'}, {'Guests': 'Tyrion', 'Friends': 'Beth', 'Enemies': 'Jon'}]
[{'Guests': 'Danerys', 'Friends': 'Jon', 'Enemies': 'Cersei'}, {'Guests': 'Jon', 'Friends': 'Danerys', 'Enemies': ['Jaime', 'Tyrion']}, {'Guests': 'Sansa', 'Friends': '-', 'Enemies': 'Cersei'}]

在现实中，宾客的数量少的也会将近一百人，会产生非常多的排列组合，而我们不需要得到所有的最优解，只需要一小部分的最优解，即可在这一小部分最优解中得到较为理想的答案