遗传算法举例
1. 遗传算法中，十进制杂交谁能个举个例子讲解一下
十进制的交叉方式有两种，一种是转换为二进制交叉，交叉好后再转为十进制；另一种是十进制直接交叉。
直接交叉就是利用交叉公式（运算公式）进行计算，以下为可选公式，分为十进制整型（变量不连接可调）和实型（变量连续可调）两种。
两个个体（个体长度为n）的十进制交叉过程如下：
1）设定交叉概率Pc；
2）随机生成【0,1】间的数b，若b<Pc，则两个进行交叉，转3），否则判断另外两个个体是否交叉；
3）采用随机多点交叉方式（可以选择单点交叉和固定多点交叉，方法类似），随机生成含n个0,1的向量y, y的每个元素对应于个体的基因（十进制数），y中为1的位置两个十进制数按上述公式进行交叉；
4）两个个体交叉完成，转入下两个个体的交叉。
例子：
设某两个个体为
X1=[1.0132, 0.9543, 0.9888, 5, 6]
X2=[1.0224, 0.9611, 0.9754, 3, 8]
直接进入步骤3），假设生成的序列y为[1,0,0,0,1]，则说明第1个和最后一个基因进行交叉，即1.0132和1.0224按以上实型公式交叉，6和8按以上整型公式交叉：
随机生成a，假设生成的a=0.65
1.0132的更新值为：0.65*1.0132+（1-0.65）*1.0224=1.01642
1.0224的更新值为：0.65*1.0224+（1-0.65）*1.0132=1.01918
随机生成另外的a，假设为a=0.6（是否需要另外生成，需要对比生成与不生成两种情况下最优解的好坏来选择）
6的更新值为：0.6*6+（1-0.6）*8=6.8，向下取整后为6
8的更新值为：0.6*8+（1-0.6）*6=7.2，向下取整后为7
因此交叉后X1和X2变为：
X1=[1.01642, 0.9543, 0.9888, 5, 6]
X2=[1.01918, 0.9611, 0.9754, 3, 7]
以此类推。
2. 遗传算法实例 java
import java.util.*;
public class Tsp {
private String cityName[]={"北京","上海","天津","重庆","哈尔滨","长春","沈阳","呼和浩特","石家庄","太原","济南","郑州","西安","兰州","银川","西宁","乌鲁木齐","合肥","南京","杭州","长沙","南昌","武汉","成都","贵州","福建","台北","广州","海口","南宁","昆明","拉萨","香港","澳门"};
//private String cityEnd[]=new String[34];
private int cityNum=cityName.length; //城市个数
private int popSize = 50; //种群数量
private int maxgens = 20000; //迭代次数
private double pxover = 0.8; //交叉概率
private double pmultation = 0.05; //变异概率
private long[][] distance = new long[cityNum][cityNum];
private int range = 2000; //用于判断何时停止的数组区间
private class genotype {
int city[] = new int[cityNum]; //单个基因的城市序列
long fitness; //该基因的适应度
double selectP; //选择概率
double exceptp; //期望概率
int isSelected; //是否被选择
}
private genotype[] citys = new genotype[popSize];
/**
* 构造函数，初始化种群
*/
public Tsp() {
for (int i = 0; i < popSize; i++) {
citys[i] = new genotype();
int[] num = new int[cityNum];
for (int j = 0; j < cityNum; j++)
num[j] = j;
int temp = cityNum;
for (int j = 0; j < cityNum; j++) {
int r = (int) (Math.random() * temp);
citys[i].city[j] = num[r];
num[r] = num[temp - 1];
temp--;
}
citys[i].fitness = 0;
citys[i].selectP = 0;
citys[i].exceptp = 0;
citys[i].isSelected = 0;
}
initDistance();
}
/**
* 计算每个种群每个基因个体的适应度，选择概率，期望概率，和是否被选择。
*/
public void CalAll(){
for( int i = 0; i< popSize; i++){
citys[i].fitness = 0;
citys[i].selectP = 0;
citys[i].exceptp = 0;
citys[i].isSelected = 0;
}
CalFitness();
CalSelectP();
CalExceptP();
CalIsSelected();
}
/**
* 填充，将多选的填充到未选的个体当中
*/
public void pad(){
int best = 0;
int bad = 0;
while(true){
while(citys[best].isSelected <= 1 && best<popSize-1)
best ++;
while(citys[bad].isSelected != 0 && bad<popSize-1)
bad ++;
for(int i = 0; i< cityNum; i++)
citys[bad].city[i] = citys[best].city[i];
citys[best].isSelected --;
citys[bad].isSelected ++;
bad ++;
if(best == popSize ||bad == popSize)
break;
}
}
/**
* 交叉主体函数
*/
public void crossover() {
int x;
int y;
int pop = (int)(popSize* pxover /2);
while(pop>0){
x = (int)(Math.random()*popSize);
y = (int)(Math.random()*popSize);
executeCrossover(x,y);//x y 两个体执行交叉
pop--;
}
}
/**
* 执行交叉函数
* @param 个体x
* @param 个体y
* 对个体x和个体y执行佳点集的交叉，从而产生下一代城市序列
*/
private void executeCrossover(int x,int y){
int dimension = 0;
for( int i = 0 ;i < cityNum; i++)
if(citys[x].city[i] != citys[y].city[i]){
dimension ++;
}
int diffItem = 0;
double[] diff = new double[dimension];
for( int i = 0 ;i < cityNum; i++){
if(citys[x].city[i] != citys[y].city[i]){
diff[diffItem] = citys[x].city[i];
citys[x].city[i] = -1;
citys[y].city[i] = -1;
diffItem ++;
}
}
Arrays.sort(diff);
double[] temp = new double[dimension];
temp = gp(x, dimension);
for( int k = 0; k< dimension;k++)
for( int j = 0; j< dimension; j++)
if(temp[j] == k){
double item = temp[k];
temp[k] = temp[j];
temp[j] = item;
item = diff[k];
diff[k] = diff[j];
diff[j] = item;
}
int tempDimension = dimension;
int tempi = 0;
while(tempDimension> 0 ){
if(citys[x].city[tempi] == -1){
citys[x].city[tempi] = (int)diff[dimension - tempDimension];
tempDimension --;
}
tempi ++;
}
Arrays.sort(diff);
temp = gp(y, dimension);
for( int k = 0; k< dimension;k++)
for( int j = 0; j< dimension; j++)
if(temp[j] == k){
double item = temp[k];
temp[k] = temp[j];
temp[j] = item;
item = diff[k];
diff[k] = diff[j];
diff[j] = item;
}
tempDimension = dimension;
tempi = 0;
while(tempDimension> 0 ){
if(citys[y].city[tempi] == -1){
citys[y].city[tempi] = (int)diff[dimension - tempDimension];
tempDimension --;
}
tempi ++;
}
}
/**
* @param indivial 个体
* @param dimension 维数
* @return 佳点集 (用于交叉函数的交叉点） 在executeCrossover()函数中使用
*/
private double[] gp(int indivial, int dimension){
double[] temp = new double[dimension];
double[] temp1 = new double[dimension];
int p = 2 * dimension + 3;
while(!isSushu(p))
p++;
for( int i = 0; i< dimension; i++){
temp[i] = 2*Math.cos(2*Math.PI*(i+1)/p) * (indivial+1);
temp[i] = temp[i] - (int)temp[i];
if( temp [i]< 0)
temp[i] = 1+temp[i];
}
for( int i = 0; i< dimension; i++)
temp1[i] = temp[i];
Arrays.sort(temp1);
//排序
for( int i = 0; i< dimension; i++)
for( int j = 0; j< dimension; j++)
if(temp[j]==temp1[i])
temp[j] = i;
return temp;
}
/**
* 变异
*/
public void mutate(){
double random;
int temp;
int temp1;
int temp2;
for( int i = 0 ; i< popSize; i++){
random = Math.random();
if(random<=pmultation){
temp1 = (int)(Math.random() * (cityNum));
temp2 = (int)(Math.random() * (cityNum));
temp = citys[i].city[temp1];
citys[i].city[temp1] = citys[i].city[temp2];
citys[i].city[temp2] = temp;
}
}
}
/**
* 打印当前代数的所有城市序列，以及其相关的参数
*/
public void print(){
/**
* 初始化各城市之间的距离
*/
private void initDistance(){
for (int i = 0; i < cityNum; i++) {
for (int j = 0; j < cityNum; j++){
distance[i][j] = Math.abs(i-j);
}
}
}
/**
* 计算所有城市序列的适应度
*/
private void CalFitness() {
for (int i = 0; i < popSize; i++) {
for (int j = 0; j < cityNum - 1; j++)
citys[i].fitness += distance[citys[i].city[j]][citys[i].city[j + 1]];
citys[i].fitness += distance[citys[i].city[0]][citys[i].city[cityNum - 1]];
}
}
/**
* 计算选择概率
*/
private void CalSelectP(){
long sum = 0;
for( int i = 0; i< popSize; i++)
sum += citys[i].fitness;
for( int i = 0; i< popSize; i++)
citys[i].selectP = (double)citys[i].fitness/sum;
}
/**
* 计算期望概率
*/
private void CalExceptP(){
for( int i = 0; i< popSize; i++)
citys[i].exceptp = (double)citys[i].selectP * popSize;
}
/**
* 计算该城市序列是否较优，较优则被选择，进入下一代
*/
private void CalIsSelected(){
int needSelecte = popSize;
for( int i = 0; i< popSize; i++)
if( citys[i].exceptp<1){
citys[i].isSelected++;
needSelecte --;
}
double[] temp = new double[popSize];
for (int i = 0; i < popSize; i++) {
// temp[i] = citys[i].exceptp - (int) citys[i].exceptp;
// temp[i] *= 10;
temp[i] = citys[i].exceptp*10;
}
int j = 0;
while (needSelecte != 0) {
for (int i = 0; i < popSize; i++) {
if ((int) temp[i] == j) {
citys[i].isSelected++;
needSelecte--;
if (needSelecte == 0)
break;
}
}
j++;
}
}
/**
* @param x
* @return 判断一个数是否是素数的函数
*/
private boolean isSushu( int x){
if(x<2) return false;
for(int i=2;i<=x/2;i++)
if(x%i==0&&x!=2) return false;
return true;
}
/**
* @param x 数组
* @return x数组的值是否全部相等，相等则表示x.length代的最优结果相同，则算法结束
*/
private boolean isSame(long[] x){
for( int i = 0; i< x.length -1; i++)
if(x[i] !=x[i+1])
return false;
return true;
}
/**
* 打印任意代最优的路径序列
*/
private void printBestRoute(){
CalAll();
long temp = citys[0].fitness;
int index = 0;
for (int i = 1; i < popSize; i++) {
if(citys[i].fitness<temp){
temp = citys[i].fitness;
index = i;
}
}
System.out.println();
System.out.println("最佳路径的序列：");
for (int j = 0; j < cityNum; j++)
{
String cityEnd[]={cityName[citys[index].city[j]]};
for(int m=0;m<cityEnd.length;m++)
{
System.out.print(cityEnd[m] + " ");
}
}
//System.out.print(citys[index].city[j] + cityName[citys[index].city[j]] + " ");
//System.out.print(cityName[citys[index].city[j]]);
System.out.println();
}
/**
* 算法执行
*/
public void run(){
long[] result = new long[range];
//result初始化为所有的数字都不相等
for( int i = 0; i< range; i++)
result[i] = i;
int index = 0; //数组中的位置
int num = 1; //第num代
while(maxgens>0){
System.out.println("----------------- 第 "+num+" 代 -------------------------");
CalAll();
print();
pad();
crossover();
mutate();
maxgens --;
long temp = citys[0].fitness;
for ( int i = 1; i< popSize; i++)
if(citys[i].fitness<temp){
temp = citys[i].fitness;
}
System.out.println("最优的解："+temp);
result[index] = temp;
if(isSame(result))
break;
index++;
if(index==range)
index = 0;
num++;
}
printBestRoute();
}
/**
* @param a 开始时间
* @param b 结束时间
*/
public void CalTime(Calendar a,Calendar b){
long x = b.getTimeInMillis() - a.getTimeInMillis();
long y = x/1000;
x = x - 1000*y;
System.out.println("算法执行时间："+y+"."+x+" 秒");
}
/**
* 程序入口
*/
public static void main(String[] args) {
Calendar a = Calendar.getInstance(); //开始时间
Tsp tsp = new Tsp();
tsp.run();
Calendar b = Calendar.getInstance(); //结束时间
tsp.CalTime(a, b);
}
}
3. 遗传算法原理与应用实例的介绍
《遗传算法原理与应用实例》主要结合应用实例系统讨论、介绍遗传算法原理及其应内用，主要内容容包括：遗传算法的基本原理和数学机理、解决连续问题优化的遗传算法和分布式遗传算法、遗传算法的实现技术、遗传算法应用实例，并给出了两个典型的遗传算法源程序。《遗传算法原理与应用实例》在详细介绍遗传算法理论与方法的同时，还给_出了基于遗传算法的费托合成反应动力学模型参数优化的详细设计应用。
4. 遗传算法 编码 例子
GA的编码通常都是数字序列（好比基因^_^），具体如何编码要看实际需求如何，例如Jeffris提到的行商问题，其编码就是一个包括n节点数字序列（也就是一条不重复走遍所有城市的路线）。
如果你愿意把你所面对的问题贴出来，或许能帮到你一些。
如果你只是在寻求多维数据结构的表现方式，很简单，无论多少维，都可以表现为(x,y,z,...)这样的坐标形式。不过我相信这不是你想要的啦^_^
最后，这个连接上有些内容或许会有点帮助（尽管可能性很小）http://..com/question/17393957.html
加油！
5. 如何利用遗传算法求解问题试举例说明求解过程急急急！！！
遗传算法将目标函数转换为适应度函数，评估，复制，交叉，变异种群中的回个体，并从答中选出适应性最强的个体，算法的最优解就是这个个体。具体流程是：1.初始种群的产生。2.适应度函数的构造。3.选择和繁殖。4.终止条件。
6. 如何通俗易懂地解释遗传算法有什么例子
相信遗传算法的官方定义你已经看过，就我个人理解
遗传算法的思想是物竞天择，优胜劣汰。
你可以理解为，当我们解某道数学题时，如果这个题太难我们没法列公式算出正确答案，我们有时候也可以蒙答案去反过来看看是否满足这道题提干的要求，如果能满足，说明我们蒙的答案是正确的。但是蒙对答案要试很多遍，每次随机的去试数可能要试1000次才能蒙对。可是遗传算法可以让我们科学的去蒙答案，每次蒙的答案都会比上一次蒙的更接近正确答案，这样可能蒙十几次我们就找到正确答案了。
希望我的回答对你理解GA有所帮助，望采纳
7. 遗传算法能不能解决线性规划顺便举个例子或者链接吧。
当然可以了，函数问题就是最简单的线性规划问题啊。在网络文库上有我的一个多目标的程序，如有需要可以下载。网络直接搜“遗传算法程序代码--多目标优化--函数最值问题”就行。