八皇后問題遺傳算法實現(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("\n");
    }
}



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\n", (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\n", (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("\n");

}


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\n", mama, papa);

    do{

        /*確定交叉點*/
        do
        {
            cp1 = rndn(N);
            cp2 = rndn(N);
            // m = abs((cp2 - cp1));
        } while (cp1 == cp2);
        //printf("%d,%d\n", 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\n", 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("\n--------------signal=%d--------------\n",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("\nmutation is complete\n");

}




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\n", rember.key[i], rember.values[i]);
}


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

}

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("\n");
    }

}


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("\n");
}





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("\n%d代數\n", generation);
            count_collidecount();
            printf("-------------output------------values----------------------------\n");
            output();
            printf("-------------outputarray----------------------------------------\n");
            outputarray();
            mating();
            printf("------------- outputarray----------------------------------------\n");
            outputarray();
            printf("-----------------mating選擇交叉---------outputnarray---------------------------\n");
            outputnarray();
            mutation();
            printf("---------- mutation-變異------------outputnarray------------------------------\n");
            outputnarray();
            printf("-------------outputarray----------------------------------------\n");
            outputarray();
            copy_array();
            printf("--------------------------------------------------------------------\n");
            output_copy_array();
            printf("------------selection------outputarray下一代種群------------------------------\n");
            selection();
            outputarray();
        }
    }

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


}