遗传算法解决N皇后问题

写代码这个事儿，果然不能懈怠，好久不定代码，都生疏了，搞了一天才搞出来。

最主要的问题是卡是杂交算法那块儿了，由于把杂交结果作为函数的返回值，而杂交结果是函数的局部变量，是一个指针，因此当函数执行结束，该指针也被释放掉，当然也就找不到杂交结果啦。

有两个方法可以解决：第一：将其作为函数的一个形参

　　　　　　　　　　第二：将其作为静态变量

下面使用两种杂交算法实现N皇后问题。

// 8queens.cpp : 定义控制台应用程序的入口点。
//
/**/

#include<iostream>
#include<string.h>
#include<time.h>
#include<map>
#include<string>
using namespace std;

#define GENERATION_LIMIT 10000
#define OFFSPRING  50
#define QUEENNUM  11
#define MAX_FITNESS 100
char fa[QUEENNUM],mo[QUEENNUM];
//我自己写的杂交算法，随机生成一个随机数mutation,如果是偶数那么将father的前mutation
//个值按顺序赋值给son，将mother的不在son中的元素按序赋值给son
//如果mutation是奇数，那么则将mother的前mutation个值按序赋值给Son
char *CrossOver1(char *father,char *mother)
{
    int i,j,k;  
    static char static_son[QUEENNUM]={'\0'};//在这里使用静态变量
    int num=0;
    bool flag[QUEENNUM];
    memset(flag,0,sizeof(flag));

    char temp[QUEENNUM]={'\0'};
    int mutation=rand()%(QUEENNUM-1);
    if(mutation%2==0)
    {
        for(i=0;i<mutation;++i)
        {
            temp[num++]=father[i];
            flag[father[i]-'0']=true;
        }
        for(i=0;(i<QUEENNUM-1)&&(num<QUEENNUM-1);++i)
        {
            if(flag[mother[i]-'0']==false)
            {
                temp[num++]=mother[i];
                flag[mother[i]-'0']=true;
            }
        }
    }
    else
    {
        for(i=0;i<mutation;++i)
        {
            temp[num++]=mother[i];
            flag[mother[i]-'0']=true;
        }
        for(i=0;(i<QUEENNUM-1)&&(num<QUEENNUM-1);++i)
        {
            if(flag[father[i]-'0']==false)
            {
                temp[num++]=father[i];
                flag[father[i]-'0']=true;
            }
        }
    }
    strcpy(static_son,temp);
    return static_son;
}
//这个算法是从网上找到的算法
char *CrossOver(char* father,char* mother)//交叉函数，返回值为交叉后的子代,具体原理不在这里阐述，在设计文档中有详细说明  
{  
    int i,j,k;  
    static char static_son[QUEENNUM]={'\0'};
    char rnd[QUEENNUM],fath[QUEENNUM],moth[QUEENNUM];
    int num=0;
    bool flag[QUEENNUM];
    memset(flag,0,sizeof(flag));
    char temp[QUEENNUM]={'\0'};
    int mutation=rand()%(QUEENNUM-1);
    strcpy(moth,mother);
    strcpy(fath,father);
    for ( i = 0; i < QUEENNUM-1; i ++)//根据交叉算子对父母进行交叉  
    {  
        if (rnd[i] == '1')  
        {  
            for ( j = 0; j < QUEENNUM-1; j++)  
            {  
                if (flag[fath[j]-'0'] ==false)  
                {  
                    break;  
                }  
            }  
            static_son[i]=fath[j];  
            flag[fath[j]-'0']=true;
        }  
        else 
        {  
            for ( j = 0; j < QUEENNUM-1; j++)  
            {  
                if (flag[moth[j]-'0'] ==false)  
                {  
                    break;  
                }  
            }  
            static_son[i]=moth[j];  
            flag[moth[j]-'0']=true; 
        }  
    }  
    return static_son;
    
}  
unsigned int check(char queen[])
{
    int illegal_num=0;
    for(int i=0;i<QUEENNUM-1;++i)
    {
        for(int j=i+1;j<QUEENNUM-1;++j)
        {
            if(abs(queen[i]-queen[j])==abs(j-i))
                ++illegal_num;
        }
    }
    return illegal_num;
}


void initqueen(char queen[])
{
    bool flag[QUEENNUM-1];
    memset(flag,0,sizeof(flag));
//    memset(queen,0,sizeof(queen));
    int place;
    for(int i=0;i<QUEENNUM-1;++i)
    {
        while(true)
        {
            place=rand()%(QUEENNUM-1);
            if(flag[place]==0)
            {
                queen[i]=place+'0';
                flag[place]=1;
                break;
            }
        }

    }
    queen[QUEENNUM-1]='\0';
}

int main()
{
    char son[2][QUEENNUM],temp[QUEENNUM];
    int max_fitness,min_fitness,fitness;
    char final_queen[QUEENNUM]={'\0'};
    int queen_num=0;
    map<string,string> mapqueen;
    //map<char*,int> mapchar;
    memset(fa,0,sizeof(fa));
    memset(mo,0,sizeof(mo));    
    srand((unsigned)time(NULL));
    initqueen(fa);    
    initqueen(mo);
    while(strcmp(fa,mo)==0)
    {
        initqueen(mo);
    }
    if(check(fa)>check(mo))//fa【】的fitness值小于mo[]的fitness值
    {
        strcpy(temp,fa);
        strcpy(fa,mo);
        strcpy(mo,temp);
    }

    // iteration
    //每一轮找出fitness值最小的两个孩子作为父亲进行下一轮的杂交
    for(int i=0;i<GENERATION_LIMIT;++i)
    {
        
        max_fitness=1000;
        min_fitness=1000;
        for(int j=0;j<OFFSPRING;++j)
        {
            strcpy(temp,CrossOver(fa,mo));
            temp[QUEENNUM-1]='\0';
            //变异
            int mutation1=rand()%(QUEENNUM-1);
            int mutation2=rand()%(QUEENNUM-1);
            int temp_mut;
            temp_mut=temp[mutation1];
            temp[mutation1]=temp[mutation2];
            temp[mutation2]=temp_mut;
            
            fitness=check(temp);
            if(min_fitness>fitness)
            {
                if(max_fitness!=1000)
                {
                    strcpy(son[1],son[0]);
                    max_fitness=min_fitness;
                }
                strcpy(son[0],temp);
                min_fitness=fitness;
            }
            else if(max_fitness>fitness&&(strcmp(temp,son[0])!=0))
            {
                max_fitness=fitness;
                strcpy(son[1],temp);
            }

            if(0==fitness)
            {
                strcpy(final_queen,temp);
                final_queen[QUEENNUM-1]='\0';
                mapqueen.insert(pair<string,string>(final_queen,final_queen));
            }
        
        }
        //将最优的孩子赋值给父母
        strcpy(fa,son[0]);
        strcpy(mo,son[1]);
        
    }
    
    map<string,string> ::iterator iter;
    for(iter=mapqueen.begin();iter!=mapqueen.end();++iter)
    {
        cout<<iter->first<<endl;
    }
    cout<<mapqueen.size()<<endl;
    
    return 0;
}