关于图着色问题（GCP）的优化算法及启发式算法求解过程——沐雨先生

最新推荐文章于 2024-05-03 10:27:39 发布

沐雨先生

最新推荐文章于 2024-05-03 10:27:39 发布

阅读量1.2k

点赞数 24

分类专栏： LNU拓展试验文章标签：算法启发式算法

本文链接：https://blog.csdn.net/qq_55376781/article/details/137543353

版权

LNU拓展试验专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、题目

图着色问题的优化算法设计和启发式算法设计，以及对结果进行必要的分析，用Python绘图，并对结果进行文字说明。

二、问题描述

图着色问题（Graph Coloring Problem, GCP）又称着色问题，是最著名的NP-完全问题之一。
数学定义：给定一个无向图G=（V, E），其中V为顶点集合，E为边集合，图着色问题即为将V分为K个颜色组，每个组形成一个独立集，即其中没有相邻的顶点。其优化版本是希望获得最小的K值。
数学模型：
在这里插入图片描述

实际问题：
①图的m可着色判定问题
给定无向连通图G和m种不同的颜色。用这些颜色为图G的各顶点着色，每个顶点着一种颜色。是否有一种着色法使G中每条边的2个顶点着不同颜色。
②图的m可着色优化问题
若一个图最少需要m种颜色才能使图中每条边连接的2个顶点着不同颜色，则称这个数m为该图的色数，即求m。

问题示例：不邻接植花（力扣1042题）
有 n 个花园，按从 1 到 n 标记。另有数组 paths ，其中 paths[i] = [xi, yi] 描述了花园 xi 到花园 yi 的双向路径。在每个花园中，你打算种下四种花之一。另外，所有花园最多有3条路径可以进入或离开。你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。以数组形式返回任一可行的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用 1、2、3、4表示。保证存在答案。
示例 1：
输入：n = 3, paths = [[1,2],[2,3],[3,1]]
输出：[1,2,3]
解释：
花园 1 和 2 花的种类不同。
花园 2 和 3 花的种类不同。
花园 3 和 1 花的种类不同。
因此，[1,2,3] 是一个满足题意的答案。其他满足题意的答案有 [1,2,4]、[1,4,2] 和 [3,2,1]

三、设计过程

优化算法（回溯法）

·设计思路：回溯法的本质其实就是一种蛮力法，只是通过一定的方法可以使得蛮力法中的一些基本情况可以提前排除从而提高蛮力算法效率，回溯可以理解为排除这些不满足条件的基本情况的过程。
·基本步骤
针对所给问题，定义问题的解空间。
确定易于搜索的解空间结构。
以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。
·思路过程
1.将上述无向图转换为邻接矩阵Graph，并根据四色定理定义颜色数量m为4。
2.由深度优先搜索解空间树，方法如下：
a) 取结点，并为结点上色。
b) 判断当前结点的颜色是否为有效颜色（即不和相邻的顶点颜色一样）。
c) 若为有效颜色，则按深度优先取下一个结点。
d) 若为无效颜色，则换下一个颜色继续进行b步骤。
e) 若所有颜色都为无效颜色，将当前结点颜色置为0，并回溯到上一个结点，进行a步骤。
f) 当找到了一个解后，令全局变量sum值加一，并通过回溯搜索下一个解。
g) 重复上述步骤，直到所有解被找到。
3.输出所有的解以及统计解的个数。

·示例着色过程
在这里插入图片描述
如图
①给顶点A着色a，由于是第一个顶点，所以一定不发生冲突。
②给顶点B着色a，和A顶点发生冲突，因此换为下一种颜色b，此时不发生冲突，因此最终给B着色b。
③给顶点C着色a，和A顶点发生冲突；给顶点C着色b，和B顶点发生冲突，因此给C顶点着色下一种颜色c，此时不发生冲突，因此最终给C着色c。
④给顶点D着色c，不发生冲突，因此最终给D着色c。
⑤给顶点E着色a，与D发生冲突；给顶点E着色b，与B发生冲突；给顶点E着色c，与C发生冲突，给顶点E着色下一种颜色d，此时不发生冲突，因此最终给E着色d。
此时所有顶点都完成着色，也就是确定了一个可行解（abcad，4种颜色），开始回溯过程。
⑥回到顶点D，由于其在上一个可行解中着色为a，因此本次对其着色为a的下一种颜色b，与B发生冲突，因此将其着色为再下一种颜色c，此时不发生冲突，因此最终将其着色为c。
⑦给顶点E着色a，不发生冲突，因此最终将顶点E着色为a。再次得到一组可行解（abcca，3种颜色）。由于该可行解使用的颜色比上一组可行解更少，因此将最优解更新为3。
⑧进行回溯：由于结点C和D的着色都是当前3种颜色中序号最大的颜色c，因此回溯到B结点，将其着色改为c。
⑨对C结点着色c，与B结点冲突，想要换为下一种颜色，但是当前只有3种颜色，因此判断算法终止，全局最优解即为3种颜色。
·算法设计流程图：
在这里插入图片描述
·用例无向图

·源代码

import numpy as np
import random
from pathlib import Path
import matplotlib.pyplot as plt
from matplotlib.pyplot import MultipleLocator#从pyplot导入MultipleLocator类，这个类用于设置刻度间隔
plt.rcParams['font.sans-serif'] = ['SimSun']
# 顶点个数
V = 5
# 颜色种类
m = 4
# 邻接矩阵
Graph = np.array([[0, 1, 1, 1, 0], [1, 0, 1, 1, 1], [1, 1, 0, 1, 0], [1, 1, 1, 0, 1], [0, 1, 0, 1, 0]])
# 颜色矩阵
C = np.zeros([1, 5])
k = 0
sum = 0#解决方案个数，置为全局变量，画图用
flag = 0#迭代次数，置为全局变量，画图用
listtimes = []#迭代次数列表，置为全局变量，画图用
listsum = []#解决方案个数列表，置为全局变量，画图用
# 判断颜色是否有效
def judge_color(Graph, k, C):
    for i in range(len(Graph[k])):
        if Graph[k][i] != 0 and C[0][k] == C[0][i]:
            return 0
    return 1

# 利用回溯寻找着色问题的解个数以及解形式
def backtrace(k, C, V, Graph):
    global sum
    global flag
    global listsum
    global listtimes
    if k < V:
        for color in range(1, m + 1):
            C[0][k] = color
            # 判断是否满足条件，若满足条件则回溯
            if judge_color(Graph, k, C):
                backtrace(k + 1, C, V, Graph)
            C[0][k] = 0
    else:
        # 输出解新式
        print(C[0])
        sum += 1#总数+1
    flag += 1#迭代次数+1
    listtimes.append(flag)#加至列表中
    listsum.append(sum)#加至列表中

backtrace(0, C, V, Graph)
print("There are %d times" % flag)#验证
print("There are %d solutions" % sum)#验证
print(listsum,listtimes)

y = listsum
x = listtimes
plt.plot(x,y,label="解决方案个数",color="red",linestyle="--",marker="s",markersize=1)

xlabel = []
for x in range(1,flag+1,10):#1-113数字太多了不方便逐个显示,步长为10
    xlabel.append(x)
plt.xticks(xlabel)# 设定x轴刻度显示为文本
plt.ylim(0,50) #设定y轴显示的区间
plt.gca().yaxis.set_major_locator(MultipleLocator(2))#设置y轴间隔为2
plt.xlabel("迭代次数")#x轴的文本说明
plt.ylabel("解决方案个数")#y轴的文本说明
plt.title("回溯法解决图着色问题")#图标题
plt.legend()#加载图例
plt.savefig("回溯法解决图着色问题.pdf")#保存图片
plt.show()#显示图片

启发式算法（遗传算法）

·设计思路：
遗传算法是一种用于解决最佳化问题的搜索算法，属于进化算法范畴。结合前述需求，首先可以将每一个区域的颜色作为一个基因，个体基因型则为全部地区颜色基因的汇总；通过构建一个类，将空间意义上的“相邻”转换为可以被遗传算法识别（即可以对个体基因改变加以约束）的信息；随后，结合子代的更替，找到满足要求的基因组；最终将得到的基因组再转换为空间意义上的颜色信息，并输出结果。
遗传操作，遗传算法中有三种遗传操作：
1.选择-复制(selection-reproduction)
2.交叉(crossover，亦称交换、交配或杂交)
3.变异(mutation，亦称突变)
·选择-复制　
通常做法是：对于一个规模为N的种群S,按每个染色体xi∈S的选择概率P(xi)所决定的选中机会, 分N次从S中随机选定N个染色体, 并进行复制。
$P(x_i) = \frac{f(x_i)}{\sum\limits_{i=1}\limits^{N}f(x_j)}$
·交叉
就是互换两个染色体某些位上的基因。
·变异
就是改变染色体某个(些)位上的基因。
例如：s=11001101，将其第三位上的0变为1, 即
s=11001101 →11101101= s′。
s′也可以看做是原s的子代。
·遗传算法步骤
选择编码策略，把参数集合（可行解集合）转换染色体结构空间；
定义适应度函数，便于计算适应值；
确定遗传策略，包括选择群体大小，选择、交叉、变异方法以及确定交叉概率、变异概率等遗传参数；
随机产生初始化群体；
计算群体中的个体或染色体解码后的适应值；
按照遗传策略，运用选择、交叉和变异算子作用于群体，形成下一代群体；
判断群体性能是否满足某一指标，或者已完成预定的迭代次数，不满足则返回第五步，或者修改遗传策略再返回第六步．

·具体分步骤思路如下：
定义“规则”。“规则”用以将区域之间的空间连接情况转换为遗传算法可以识别的信息；被“规则”连接的两个区域在空间中是相邻的。
定义区域空间连接情况检查所需函数。这些函数用于检查两两区域之间的连接性是否满足逻辑；例如，若在“规则”中显示区域1与区域2连接，那么区域2也必须在“规则”中显示与区域1连接。
定义个体基因型。其中，各个体具有5个基因（5个区域），每一个基因表示一个区域的颜色。
个体更替与最优基因选择。通过个体的不断更迭，选择出满足“规则”要求的个体基因型。
基因型解释。将得到的个体基因型进行解释，相当于第一步的反过程，即将基因信息转换为空间连接情况。
结果检查。检查所得到的颜色与最优个体基因组中的各个基因是否一致。

·算法设计流程图：
在这里插入图片描述
·用例无向图（同回溯法）
·代码

POPULATION_SIZE = 100
P_CROSSOVER = 0.9
P_MUTATION = 0.1
MAX_GENERATIONS = 100
HALL_OF_FAME_SIZE = 10
MAX_COLORS = 10

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import random
from pathlib import Path
from matplotlib.pyplot import MultipleLocator#从pyplot导入MultipleLocator类，这个类用于设置刻度间隔
plt.rcParams['font.sans-serif'] = ['SimSun']

class GraphColoringProblem:
    def __init__(self, graph, hardConstraintPenalty):
        # 初始化实例变量
        self.graph = graph
        self.hardConstraintPenalty = hardConstraintPenalty
        # 创建图节点的列表
        self.nodeList = list(self.graph.nodes)
        # 创建图的邻接矩阵
        self.adjMatrix = nx.adjacency_matrix(graph).todense()

    def __len__(self):
        """
        :return: the number of nodes in the graph
        """
        return nx.number_of_nodes(self.graph)

    def getCost(self, colorArrangement):
        """
        计算给定颜色组合的总成本
        """
        return self.hardConstraintPenalty * self.getViolationsCount(colorArrangement) + self.getNumberOfColors(
            colorArrangement)

    def getViolationsCount(self, colorArrangement):
        """
        计算给定颜色排列中违反颜色的次数
        """
        if len(colorArrangement) != self.__len__():
            raise ValueError("size of color arrangement should be equal to ", self.__len__())

        violations = 0

        # 遍历每对节点，查找它们之间是否存在链接并使用相同的颜色
        for i in range(len(colorArrangement)):
            for j in range(i + 1, len(colorArrangement)):
                if self.adjMatrix[i, j]:
                    if colorArrangement[i] == colorArrangement[j]:
                        violations += 1

        return violations

    def getNumberOfColors(self, colorArrangement):
        """
        计算给定颜色排列使用的颜色数量
        """
        return len(set(colorArrangement))

    def plotGraph(self, colorArrangement):
        """
        绘制具有根据给定颜色排列进行着色的图
        """

        if len(colorArrangement) != self.__len__():
            raise ValueError("size of color list should be equal to ", self.__len__())
        # 创建唯一色列表
        colorList = list(set(colorArrangement))
        # 创建实际颜色列表
        colors = plt.cm.rainbow(np.linspace(0, 1, len(colorList)))
        # 遍历节点，并根据颜色组合分配颜色
        colorMap = []
        for i in range(self.__len__()):
            color = colors[colorList.index(colorArrangement[i])]
            colorMap.append(color)
        # 对相应节点进行着色
        nx.draw_kamada_kawai(self.graph, node_color=colorMap, with_labels=True)
        return plt


def main():
    # 创建初始种群
    population = toolbox.populationCreator(n=POPULATION_SIZE)

    # 定义监听统计数据
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("min", np.min)
    stats.register("avg", np.mean)
    hof = tools.HallOfFame(HALL_OF_FAME_SIZE)
    # 执行遗传流程
    population, logbook = eaSimpleWithElitism(population,
                                              toolbox,
                                              cxpb=P_CROSSOVER,
                                              mutpb=P_MUTATION,
                                              ngen=MAX_GENERATIONS,
                                              stats=stats,
                                              halloffame=hof,
                                              verbose=True)

    print("There are %d times" % flag)  # 验证
    print("There are %d solutions" % sum)  # 验证
    print(listsum, listtimes)

    y = listsum
    x = listtimes
    plt.plot(x, y, label="解决方案个数", color="red", linestyle="--", marker="s", markersize=1)

    xlabel = []
    for x in range(1, flag + 1, 10):  # 1-90数字太多了不方便逐个显示,步长为10
        xlabel.append(x)
    plt.xticks(xlabel)  # 设定x轴刻度显示为文本
    plt.ylim(0, 50)  # 设定y轴显示的区间
    plt.gca().yaxis.set_major_locator(MultipleLocator(2))  # 设置y轴间隔为2
    plt.xlabel("迭代次数")  # x轴的文本说明
    plt.ylabel("解决方案个数")  # y轴的文本说明
    plt.title("遗传算法解决图着色问题")  # 图标题
    plt.legend()  # 加载图例
    plt.savefig("遗传算法解决图着色问题.pdf")  # 保存图片
    plt.show()  # 显示图片