八皇后问题遗传算法实现(python版）

八皇后问题的遗传算法实现过程详解

 

1、八皇后问题描述
19 世纪著名的数学家Gauss 在1850 年提出八皇后问题后， 该问题成为各类语言程序设计的经典题目。八皇后问题要求在8×8 格的国际象棋上摆放八个皇后，使横、竖、斜方向上都不能有两个及两个以上皇后在同一条直线上， 问题也可以推广到N 个皇后。穷举法在问题规模不大的情况下还可适用，回溯法是求解此问题的经典算法。但N 皇后问题是个NP 难问题， 随着皇后数目的增多， 求解复杂度激增， 就需利用非常规的技术求解。遗传算法在求解一些NP 完全问题上得到了广泛地应用，本文用遗传算法求解八皇后问题，给出详细的实现过程。

2、基本遗传算法求解过程
 基本遗传以初始种群为基点， 经过选择、交叉、变异操作生成新的种群，如此更新种群直到满足终止条件。其计算步骤如下：
（1） 将问题空间转换为遗传空间， 也就是编码；
（2）随机生成P 个染色体作为初始种群；
（3）染色体评价，也就是按确定的适应度函数
计算各个染色体的适应度；
（4）根据染色体适应度，按选择算子进行染色体的选择；
（5）按交叉概率进行交叉操作；
（6）按变异概率进行变异操作；
（7）返回（4）形成新的种群，继续迭代，直到满足终止条件。

基本遗传算法给出了基本框架， 针对求解的问题不同， 遗传算法在相应的计算步骤中有不同的设计。本文针对八皇后问题， 设计了相应的编码，适应度计算方法，交叉和变异操作。

 

3、用遗传算法求解八皇后问题实现过程详解

 

3.1 编码
遗传算法中传统的编码是二进制编码， 本文采用多值编码。染色体长度取决于皇后的个数。染色体中每个基因所处的位置表示其在棋谱中所在的行数， 基因值表示其所在的列数。如染色体40752613 表示：从0 开始数，第0 个4 表示在第零行的皇后在第4 列， 第1 个0 表示第一行的皇后在第0 列，以此类推。八皇后问题中皇后不能处于同行同列， 意味着染色体中0～7 的基因取值不能出现重复。

 

3.2 个体评价
染色体通常表示了问题的可行解， 对可行解进行遗传操作寻找最优解。但在八皇后问题中，染色体仅仅体现同行同列中未出现互攻， 在对角线上是否出现互攻还未做考虑。在对皇后的位置做比较的时候， 可以对两个棋子的行数差与列数差进行对比， 实现了互攻次数的统计。公式为：|绝对值((y2-y1)/(x2-x1)) |=1。公式中（x1，y1），(x2，y2)分别表示两个皇后所在的位置，即所在的行数和列数。当两个皇后的行数差与列数差比值的绝对值为1 的时候，两皇后在同一对角线上，即出现了互攻。每个染色体内的互攻次数为Value，初始值设为0；第0 行与1～7 行进行比较， 每出现一次互攻则Value 的值增加1；第1 行与2～7 行进行比较，以此类推来计算Value 值。当Value 为0 表示没有发生互攻，此染色体就是其中的一个可行解。当Value 不为0则进行适应度的计算。一般来说， 适应度越大越
好，而互攻次数为越小越好，所以可以将适应度的计算函数设置为：F=28-Value。

 

3.3 选择
选择使用的是经典的赌轮选择方法， 与基本遗传算法的实现无特别之处，此处不赘述。

 

3.4 交叉

经典的单点， 多点等交叉因染色体中不能出现重复的基因值，在该问题中不适用。本文使用部分匹配交叉，具体操作如下：

1)在染色体中随机选取两个点标记为y，

如：染色体a：01y24y3675；

染色体b：12y30y4576;

两个y 之间的基因段称为中间段， 记录其对应关系2-3，4-0；

2)对染色体a，b 的中间段进行交换，

形成染色体a'：01y30y3675；染色体b': 12y24y4576;

3) 利用对应关系，对染色体a'， b' 中间段外的基因进行交换，

形成 染色体a''： 41y30y2675；

染色体b'':   13y24y0576;

交叉完成。

 

3.5 变异
采用多值编码后， 变异操作并不能通过简单的0，1 反转实现。

本文采取随机地选取染色体内的两个基因进行交换来实现。

例如随机选取的是
6 和1 两个基因，那么
变异前染色体： 7 （6） 5 4 3 2 （1） 0
变异后染色体： 7 （1） 5 4 3 2 （6） 0

 

3.6 终止策略
本文采用的终止策略为： 当群体中出现染色体的适应值为0 时， 即表示算法搜索到了一个可行解，终止算法。若算法运行设置的代数还未找到可行解，同样终止程序运行。

 

4、总结
本文详细介绍了用遗传算法求解八皇后问题的求解过程， 但要注意的是这只是其中的一种编码，交叉，变异等操作设计方法，还有许多其他的方法可以选择。对于各操作采取不同设计方案的遗传算法，其算法性能值得比较讨论。

 

 

#
#   遗传算法（八皇后问题）
#   最佳值28
import random
import numpy


N=8  #皇后数
Cluster_size=12   #默认种群大小
LASTG=100    #/*终止后代*/
MRATE=0.8  #/*突变的概率*/
array=numpy.zeros((Cluster_size,N)).astype(int) #染色体集合
narray=numpy.zeros((Cluster_size * 2,N)).astype(int) #下一代染色体集合
_array=numpy.zeros((Cluster_size,N)).astype(int)#array数组的副本
values=numpy.zeros(Cluster_size).astype(int) #评估数组
max_array=numpy.zeros(N).astype(int) #保存最佳数组
generation = 0 #记录代数
signal = -1   # 信号
max = -1 # 记录当前最优值
max_generation = -1  #记录当前最优值代数



class Struct:
    key = numpy.zeros(N).astype(int)
    values = numpy.zeros(N).astype(int)


rember=Struct()


def rndn(l):
    rndno =random.randint(0,l-1)
    return rndno


def copy_array():
    for i in range(Cluster_size):
        for j in range(N):
            _array[i][j]=array[i][j]


def output_copy_array():
    for i in range(Cluster_size):
        for j in range(N):
            print(_array[i][j],end=" ")
        print()


def the_answer(values,size):
    for i in range(size):
        if values[i]==28:
            return i
    return -1


def judge(a,n):
    value = -1
    for i in range(n):
        value = a[i]
        j=i+1
        while j<n:
            if(value==a[j]):
                return 0
            j+=1
    return 1



def count_collidecount():
    value=0
    global signal
    for i in range(Cluster_size):
        for j in range(N):
            x1=j
            y1=array[i][j]
            m=j+1
            while m<N:
                x2=m
                y2=array[i][m]
                if (abs((y2-y1)/(x2-x1))==1):
                    value+=1
                m+=1
        values[i]=28-value
        value=0
    signal= the_answer(values,Cluster_size)



def count_generation_collidecount(values,cluster_size):
    value=0
    for i in range(cluster_size):
        for j in range(N):
            x1=j
            y1=narray[i][j]
            m=j+1
            while m<N:
                x2=m
                y2=narray[i][m]
                if(abs((y2 - y1) / (x2 - x1))==1):
                    value+=1
                m+=1
        values[i]=28-value
        value=0


# /************************/
# /*   selectp()函数      */
# /*    父代的选择        */
# /************************/
def selectp(roulette,totalfitness):
    acc=0
    ball=rndn(totalfitness)
    for i in range(Cluster_size):
        acc+=roulette[i]
        if (acc>ball):
            break
    return i


def  takeoutrepeat( position):
    signal=True
    for i in range(N):
        value = narray[position*2][i]
        j=i+1
        while j<N:
            if (narray[position*2][j]==value):
                # print("there have reapt number: "+str(position*2))
                signal=False
            j+=1
    for i in range(N):
        value=narray[position*2+1][i]
        j=i+1
        while j<N:
            if (narray[position*2+1][j]==value):
                # print("there have reapt number: "+str(position*2+1))
                signal=False
            j+=1
    return signal




def judge_reapt(c, cluster):
    value =0
    arraysEqual =True
    i=0
    for j in range(cluster):
        while (arraysEqual and i<N):
            if (narray[c][i] !=_array[j][i]):
                arraysEqual=False
            i+=1
        if(arraysEqual):
            value+=1
        else:
            arraysEqual=True
        i=0

    if(value>0):
        return False
    else:
        return True




# /************************/
#  /*   selection()函数      */
#  /*   选择下一代          */
#  /************************

def selection():
    global signal
    global max_generation
    global max
    totalfitness=0
    roulette=numpy.zeros(Cluster_size*2).astype(int)
    acc=0
    for i in range(Cluster_size):
        totalfitness=0
        count_generation_collidecount(roulette,Cluster_size*2)
        c=0
        while c<Cluster_size*2:
            totalfitness+=roulette[c]
            c+=1
        signal=the_answer(roulette,Cluster_size*2)

        while True:
            ball =rndn(totalfitness)
            acc=0
            c=0
            while c<Cluster_size*2:
                acc+=roulette[c]
                if acc>ball:
                    break
                c+=1
            judge=judge_reapt(c,Cluster_size)
            if judge==True:
                break
        #/ *染色体的复制 * /
        for j in range(N):
            array[i][j]=narray[c][j]

    for q in range(Cluster_size*2):
        if roulette[q]>max:
            max =roulette[q]
            max_generation = generation
            for i in range(N):
                max_array[i]=narray[q][i]
        print(roulette[q], end=" ")
    print()






def judgein(m,location1,location2):
    i=location1
    while i<=location2:
        if ((m == rember.key[i]) | (m == rember.values[i])):
            return i
        i+=1
    return -1






 # /************************/
 # /*  crossing()函数      */
 # /* 特定2染色体的交叉    */
 # /************************/
def crossing(mama, papa,position):
    while True:
        while True:
            cp1 = rndn(N)
            cp2 = rndn(N)
            if cp1 != cp2:
                break
        # print("cp1="+str(cp1)+"cp2="+str(cp2))
        if cp1<cp2:
            location1 = cp1
            location2 = cp2
        else:
            location1 = cp2
            location2 = cp1

        i = location1
        while i<=location2:
            rember.key[i] = array[mama][i]
            rember.values[i] = array[papa][i]
            # 交换中间段
            narray[position*2][i] = array[papa][i]
            narray[position*2+1][i] = array[mama][i]
            i+=1
        # 利用对应关系，对染色体mama和papa, 中间段外的基因进行交换
            #/ * 交换前半部分 * /
        for j in range(location1):
            weizhi = judgein(array[mama][j],location1,location2)
            # print("weizhi= "+str(weizhi))
            if (weizhi == -1):
                narray[position*2][j] = array[mama][j]
            else:
                if (array[mama][j] == rember.key[weizhi]):
                    narray[position*2][j] = rember.values[weizhi]
                else:
                    narray[position*2][j] = rember.key[weizhi]
            weizhi = judgein(array[papa][j], location1, location2)
            if (weizhi == -1):
                narray[position*2+1][j] = array[papa][j]
            else:
                if (array[papa][j] == rember.key[weizhi]):
                    narray[position*2+1][j] = rember.values[weizhi]
                else:
                    narray[position*2+1][j] = rember.key[weizhi]


         #/ *交换后半部分 * /
        j = location2+1
        while j<N:
            weizhi = judgein(array[mama][j], location1, location2)
            if (weizhi == -1):
                narray[position*2][j] = array[mama][j]
            else:
                if (array[mama][j] == rember.key[weizhi]):
                    narray[position*2][j] = rember.values[weizhi]
                else:
                    narray[position*2][j] = rember.key[weizhi]
            weizhi = judgein(array[papa][j],location1,location2)
            if (weizhi == -1):
                narray[position*2+1][j] = array[papa][j]
            else:
                if (array[papa][j] == rember.key[weizhi]):
                    narray[position*2+1][j] = rember.values[weizhi]
                else:
                    narray[position*2+1][j] = rember.key[weizhi]
            j+=1

        signal = takeoutrepeat(position)
        # print("--------------signal= "+str(signal))
        if (signal != False):
           break






        # /************************/
 # /*   notval()函数       */
 # /*                      */
 # /************************/
def notval(i):
    while True:
        position1 =rndn(N)
        position2 =rndn(N)
        if position1 != position2:
            break
    temp=narray[i][position2]
    narray[i][position2] = narray[i][position1]
    narray[i][position1] =temp




#  /***********************/
# /*   mutation()函数    */
#  /*   突变              */
#  /***********************/
def mutation():
    for i in range(Cluster_size*2):
        if (rndn(100) / 100 <= MRATE):
            #/ *染色体突变 * /
             notval(i)
    print("mutation is complete")





def mating():
    totalfitness =0
    roulette=numpy.zeros(Cluster_size).astype(int)
    print(len(roulette))
     # 生成轮盘
    for i in range(Cluster_size):
        roulette[i] = values[i]
        totalfitness += roulette[i]
    #  选择和交叉的循环
    for i in range(Cluster_size):
        while True:
            mama=selectp(roulette,totalfitness)
            papa=selectp(roulette,totalfitness)
            if mama != papa:
                break
        # 特定2染色体的交叉
        crossing(mama,papa,i)



def outputrember():
    for i in range(N):
        print("key= "+rember.key[i]+"values= "+rember.values[i])




def outputnarray():
    for i in range(Cluster_size*2):
        if (i % 2 ==0):
            print("------------------------------")
        for j in range(N):
            print(narray[i][j],end=" ")
        print()




def output():
    global max
    global max_generation
    for i in range(Cluster_size):
        if values[i]>max:
            max =values[i]
            max_generation=max_generation
        print(values[i],end=" ")
    print()




def outputarray():
    for i in range(Cluster_size):
        for j in range(8):
            print(array[i][j], end =" ")
        print()





def init_Cluster():
    print('fsadsgagasgs')
    a=[0 for n in range(8)]
    count=0
    while count < Cluster_size:
         for y in range(8):
             x= random.randint(0,7)  #产生0到7的随机数
             a[y]=x
         if(judge(a,8)):
             for i in range(8):
                 array[count][i]=a[i]
         else:
             count=count-1
         count+=1





def main():
    global generation
    init_Cluster()
    while generation<LASTG:
        if signal!=-1:
            break
        else:
            print("代数= "+str(generation))
            count_collidecount()
            print("-------------output------------values--------------------------")
            output()
            print("------------- outputarray--------------------------------------")
            outputarray()
            mating()
            print("------------- outputarray--------------------------------------")
            outputarray()
            print("-----------------mating选择交叉---------outputnarray---------------")
            outputnarray()
            mutation()
            print("-----------------mutation变异---------outputnarray---------------")
            outputnarray()
            print("------------- outputarray--------------------------------------")
            outputarray()
            copy_array()
            # print("---------------------------------------------------------------")
            # output_copy_array()
            selection()
            print("-----------------selection选择下一代--------outputarray---------------")
            outputarray()
        generation+=1
    print("signal = "+str(signal)+" max ="+str(max)+" max_generation = "+str(max_generation)) #max为最佳值， max_generation为产生最佳值的代数
    print(max_array,end=" ")


if __name__ == "__main__":
    main()