八皇后问题遗传算法实现(C语言）

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

 

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

 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>    
#include <math.h>    

//
//    编程题
//  遗传算法（八皇后问题）
//


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


struct MyStruct
{
    int  key[Cluster_size];
    int  values[Cluster_size];
} rember;  //交叉时记录对应关系


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


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

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


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


/*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=1/Value。*/





/*编码方案
遗传算法的常用编码方案有排列编码、二进制编码、实值编码等，考虑到编码方案需要较好地对应一种棋盘皇后排列顺序，
同时八皇后问题需要解决的是实体目标（即皇后）的排列问题，不涉及到浮点数层面的逼近问题，本程序采用排列编码作为编码方案，具体描述如下：
用一维n元数组x0,1…,n-1来表示一个个体，其中x[i]∈{0,1…,n-1}，x[i]表示皇后i放在棋盘的第i行第x[i]列，即第i行第x[i]列放置一个皇后。
例如，x[0]=0表示棋盘的第0行第0列放一个皇后。数组第i个元素表示第i行的放置情况，可以看作一个基因。
这种编码可以自然的解决了某一行只能放一个皇后的约束，如果数组的每一个元素x[i]都不重复，可以看成0 — 7的一种排列，就自然保证每一列只能放一个皇后。
在编码方案实现过程中，我们对染色体编码是否可重复问题进行了讨论，经实验发现不允许染色体编码重复的方案，
即每一个编码必须为0-7排列的编码方案的搜索空间为8！种，而允许编码出现重复的方案搜索空间为8^8种，
在实验运行过程中第一种编码方案运行所需代数平均值比第二种方案要小一个数量级，因此最终决定采用了不允许染色体编码重复的方案，
n元数组x[0,1…,n-1]中，每一个x[i]不允许重复，在程序运行过程中，无论是初始种群生成，选择，交叉，变异阶段都会维护这一编码准则。
*/


/*初始种群
初始化种群的主要工作为：确定种群的大小及产生初始种群.种群的大小能够对遗传算法的收敛性产生很大的影响，
种群较小算法收敛速度较快，但它的搜索面不够广，容易导致局部收敛；而种群较大算法收敛全局最优的概率也大，
但是算法的收敛速度较慢。根据N皇后问题的特点，默认初始种群大小一般为N ~ 2N (N为皇后数)。经多次实验，
初始种群大小的设置从8、12、16、24没有较大区别，对遗传代数没有突出影响，因此将默认初始种群大小设为12，界面中提供了用户自行设定初始种群大小的方法。
除此之外，程序提供了两种初始种群的生成方法，第一种是随机生成，程序将自动生成用户设定数量的随机个体作为初始种群，
第二种是用户输入，程序初始种群一栏提供了用户自行输入每一个个体基因编码的接口。值得注意的是，以上无论哪种方法，
生成的都是0-7不含重复的8位随机排列。系统不会接受任何编码出现重复的非法个体。
*/



int rndn(int l)
{
    int rndno;
    rndno = rand()%l;
    return rndno;

}


void output_copy_array()
{
    for (int i = 0; i < Cluster_size; i++)
    {
        for (int j = 0; j < N; j++)
            printf("%d", copyarray[i][j]);
        printf("
");
    }
}



void output_maxarray()
{
    for (int i = 0; i < N; i++)
        printf("%d", max_array[i]);
}






//判断是否有最优解
int  the_answer(int* values, int size)
{
    for (int i = 0; i < size; i++)
        if (values[i] == 28)
            return i;
    return -1;
}



int judge(int a[], int n)
{
    int i, j;
    int value = -1;
    for (i = 0; i < n; i++) {
        value = a[i];
        for (j = i + 1; j < n; j++) {
            if ((value == a[j])) {
                return 0;
            }
        }
    }
    return 1;

}





//计算初始适应度值
void count_collidecount() //适应度函数设置为：value[i]=28-value
{

    int i, j, x1, x2, y1, y2, m, value = 0;
    for (i = 0; i < Cluster_size; i++) {

        for (j = 0; j < N; j++)
        {
            x1 = j;
            y1 = array[i][j];
            for (m = j + 1; m < N; m++)
            {
                x2 = m;
                y2 = array[i][m];
                if (abs((y2 - y1) / (x2 - x1))==1)
                    value++;
            }

        }
        values[i] = 28 - value;
        value = 0;
    }

    signal = the_answer(values, Cluster_size);

}


//计算子代适应度值
void count_generation_collidecount(int* values, int cluster_size)
{

    int i, j, x1, x2, y1, y2, m, value = 0;
    for (i = 0; i < cluster_size; i++) {

        for (j = 0; j < N; j++)
        {
            x1 = j;
            y1 = narray[i][j];
            for (m = j + 1; m < N; m++)
            {
                x2 = m;
                y2 = narray[i][m];
                if (abs((y2 - y1) / (x2 - x1))==1)
                    value++;
            }

        }
        values[i] = 28 - value;
        value = 0;
    }

   
}





/************************/
/*   selectp()函数      */
/*    父代的选择        */
/************************/
int selectp(int roulette[], int totalfitness)
{
    int i;/* 循环的控制变量 */
    int ball;/* 球（选择位置的数值）*/
    int acc = 0;/*评价值的累积值*/

    ball = rndn(totalfitness);
    for (i = 0; i < Cluster_size; i++) {
        acc += roulette[i];/*评价值的累积*/
        if (acc > ball) break;/*对应的基因*/
    }
    return i;
}






bool takeoutrepeat(int position)//去除有重复元素的数组，并添加无重复值的数组（染色体）
{

    int i;
    int value;
    bool signal = true;


    for (i = 0; i < N; i++)
    {
        value = narray[position*2][i];
        for (int j = i + 1; j < N; j++)
            if (narray[position*2][j] == value)
            {
                printf("there have reapt number: %d
", (position*2));
                signal = false;
            }

    }

    for (i = 0; i < N; i++)
    {
        value = narray[position * 2+1][i];
        for (int j = i + 1; j < N; j++)
            if (narray[position * 2+1][j] == value)
            {
                printf("there have reapt number: %d
", (position*2+1));
                signal = false;
            }
    }

    return signal;


}


//判断两个数组是否相等
bool judge_reapt(int c,int cluster)
{

    int i,j;
    int value=0;
    bool arraysEqual = true;

    for (i=0,j = 0; j < cluster; j++)
    {
        while (arraysEqual && i < N)
        {
            if (narray[c][i] != copyarray[j][i])
                arraysEqual = false;
            i++;
        }
        //显示合适的消息
        if (arraysEqual)
            value++;
        else
            arraysEqual = true;

        i = 0;//i置0
    }

    if (value > 0)
        return false;
    else
        return true;

}


/************************/
/*   selection()函数      */
/*   选择下一代          */
/************************/
void selection()
{
    int i, j, c;/* 循环控制参数 */
    int totalfitness = 0;/*适应度的总计值*/
    int roulette[Cluster_size * 2];/*存放适应度*/
    int ball;/* 球（选择位置的数值）*/
    int acc = 0;/*适应度的累积值*/
    bool judge;

        /*循环进行选择*/
        for (i = 0; i < Cluster_size; i++) {
            /* 生成轮盘 */
            totalfitness = 0;
            count_generation_collidecount(roulette, Cluster_size * 2);

            for (c = 0; c < Cluster_size * 2; ++c) {
                /*计算适应度的总计值*/
                totalfitness += roulette[c];
            }
            signal = the_answer(roulette, Cluster_size * 2);//判断是否有最优解

            do 
            {
                /*选择一个染色体*/
                ball = rndn(totalfitness);
                acc = 0;
                for (c = 0; c < Cluster_size * 2; ++c) {
                    acc += roulette[c];/*累积评价值*/
                    if (acc > ball) break;/*对应的基因*/
                }
               judge= judge_reapt(c, Cluster_size );

            } while (judge==false);

            
            /*染色体的复制*/
            for (j = 0; j < N; ++j) {
                array[i][j] = narray[c][j];
            }
        }

    for (int q = 0; q< Cluster_size *2; q++)
    {   
        if (roulette[q] > max)
        {
            max = roulette[q];
            max_generation = generation;
            for (int i = 0; i < N; i++)
                max_array[i] = narray[q][i];
        }
        printf("%3.1d", roulette[q]);

    }
    printf("
");

}


int judgein(int m, int location1, int location2)
{
    for (int i = location1; i <= location2; i++)
        if ((m == rember.key[i]) | (m == rember.values[i]))
            return i;
    return -1;
}




/************************/
/*  crossing()函数      */
/* 特定2染色体的交叉    */
/************************/
void crossing(int mama, int papa, int position)
{
    bool signal;
    int cp1;/*交叉的点*/
    int cp2;/*交叉的点*/
    int location1;
    int location2;
    printf("mama=%d,papa=%d
", mama, papa);

    do{

        /*确定交叉点*/
        do
        {
            cp1 = rndn(N);
            cp2 = rndn(N);
            // m = abs((cp2 - cp1));
        } while (cp1 == cp2);
        //printf("%d,%d
", cp1, cp2);
        if (cp1 < cp2)
        {
            location1 = cp1;
            location2 = cp2;
        }
        else
        {
            location1 = cp2;
            location2 = cp1;
        }


        for (int i = location1; i <= location2; i++)
        {
            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];
        }
        //利用对应关系，对染色体mama和papa, 中间段外的基因进行交换
           /*交换前半部分*/
        for (int j = 0; j < location1; j++)
        {
            int weizhi = judgein(array[mama][j], location1, location2);
           // printf("weizhi=%d
", 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];
            }

        }


        ///*交换后半部分*/
        for (int j = location2 + 1; j < N; j++)
        {
            int 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];

            }
        }
       
        signal = takeoutrepeat(position);
        printf("
--------------signal=%d--------------
",signal);
    } while (signal==false);


}


/************************/
/*   notval()函数       */
/*                      */
/************************/
void notval(int i)
{
    int position1;
    int position2;
    int temp; //两个基因点交换的中间变量
    do
    {
        position1 = rndn(N);
        position2 = rndn(N);

    } while (position2 == position1); //当两个变异基因点相同时，循环。

    temp = narray[i][position2];
    narray[i][position2] = narray[i][position1];
    narray[i][position1] = temp;

}



/***********************/
/*   mutation()函数    */
/*   突变              */
/***********************/
void mutation()
{
    int i;/* 循环的控制变量 */

    for (i = 0; i < Cluster_size * 2; ++i)
            if ((rndn(100) / 100)<= MRATE)
                /*染色体突变*/
                notval(i);
    printf("
mutation is complete
");

}




void mating()
{

    int i;
    int totalfitness = 0;
    int roulette[Cluster_size];//存放评价值
    int mama, papa; //父代的基因的号码

   // 生成轮盘
    for (i = 0; i < Cluster_size; ++i)
    {
        roulette[i] = values[i];
        totalfitness += roulette[i];
    }

    //选择和交叉的循环
    for (i = 0; i < Cluster_size; i++)
    {
        do {  //父代的选择
            mama = selectp(roulette, totalfitness);
            papa = selectp(roulette, totalfitness);
        } while (mama == papa);

        //特定2染色体的交叉
        crossing(mama, papa, i);
    }

}






void outputrember()
{
    for (int i = 0; i < N; i++)
        printf("key=%d,values=%d
", rember.key[i], rember.values[i]);
}


void outputnarray()
{
    for (int i = 0; i < Cluster_size * 2; i++)
    {
        if (i % 2 == 0)
            printf("---------------------------------------------------
");
        for (int j = 0; j < N; j++)
            printf("%d", narray[i][j]);
        printf("
");
    }

}

void copy_array()
{
   
    for (int i = 0; i < Cluster_size; i++)
        for (int j = 0; j < N; j++)
        {      
            copyarray[i][j] = array[i][j];
        }
}


void outputarray()
{
    for (int i = 0; i < Cluster_size; i++)
    {
        for (int j = 0; j < N; j++)
            printf("%d", array[i][j]);
        printf("
");
    }

}


void output()
{
    int i;
    for (i = 0; i < Cluster_size; i++)
    {
        if (values[i] > max)
        {
            max = values[i];
            max_generation = generation;
        }
        printf("%3.1d", values[i]);

    }
    printf("
");
}





void init_Cluster()
{
    int a[8];
    int x, y;
    int count = 0;

    for (; count < Cluster_size; count++)
    {

        for (y = 0; y < 8; y++)
        {
            x = rand() % 8;
            a[y] = x;
        }

        if (judge(a, 8))
        {
            for (int i = 0; i < 8; i++)
            {
                array[count][i] = a[i];
            }
        }
        else
            --count;

    }

}




int main()
{
    srand((int)time(NULL));     //随机种子
    init_Cluster();

    for (; generation < LASTG; generation++)
    {

        if (signal != -1)
            break;
        else
        {

            printf("
%d代数
", generation);
            count_collidecount();
            printf("-------------output------------values----------------------------
");
            output();
            printf("-------------outputarray----------------------------------------
");
            outputarray();
            mating();
            printf("------------- outputarray----------------------------------------
");
            outputarray();
            printf("-----------------mating选择交叉---------outputnarray---------------------------
");
            outputnarray();
            mutation();
            printf("---------- mutation-变异------------outputnarray------------------------------
");
            outputnarray();
            printf("-------------outputarray----------------------------------------
");
            outputarray();
            copy_array();
            printf("--------------------------------------------------------------------
");
            output_copy_array();
            printf("------------selection------outputarray下一代种群------------------------------
");
            selection();
            outputarray();
        }
    }

    printf("
signal = %d, max = %d, max_generation = %d
", signal,max,max_generation);
    output_maxarray();
    return 0;


}