初学遗传算法，一个练手的小程序

    最近研究了一下遗传算法，挺有意思的，在一个老外的网站上看到了这个小例子，比较有趣，自己用java实现了一下（老外是用c++实现的）。
    问题：有10张纸牌，编号分别是1到10，现在要将这10张纸牌分为2堆，其中一堆求和为36，另一堆求积为360，问应该怎么分？ （也就是说，最终的结果应该是：一堆为2+7+8+9+10=36，另一堆为1*3*4*5*6=360。当然，如果修改题目中的参数，改为32和360，那么结果就是2+3+4+6+7+10=32 和 1*5*8*9=360）
原文地址： http://www.codeproject.com/KB/recipes/Genetic_Algorithm.aspx
另外，这个算法不保证每次都有结果，一般多运行几次是会得到结果的，当然，如果本身无解，那自然是永远也找不到结果的。

1. package andycpp;
3. import java.util.Random;
5. public class CardGA {
7.     /**
8.      * @param args
9.      */
10.     public static void main(String[] args) {
11.         new CardGA().run();
12.     }
14.     private final int pop_size = 30;        //人口池容量
15.     private final int chrom_length = 10;    //染色体长度
16.     private final float crossover_rate = 0.6f;  //杂交率
17.     private final float mutation_rate = 0.01f;  //变异率
18.     private final int max_generation = 1000;    //繁殖次数的上限
19.     private final int sum_tagart = 32;          //纸牌求和的目标值
20.     private final int product_targart = 360;    //纸牌求积的目标值
21.     private static Random rand = new Random();  //随机数产生器
22.     
23.     private int[][] population = new int[pop_size][chrom_length];   //人口池
24.     
25.     public void run() {
26.         int generation = 0;
27.         initPopuation(population);
28.         int winner = 0, loser = 0;
29.         while(generation < max_generation) {
30.             generation++;
31.             winner = rand.nextInt(pop_size);
32.             loser = rand.nextInt(pop_size);
33.             if(getFitness(winner) > getFitness(loser)) {
34.                 int temp = winner;
35.                 winner = loser;
36.                 loser = temp;
37.             }
38.             if(isAnswer(winner))
39.                 break;
40.             crossover(winner, loser);
41.             mutation(loser);
42.             if(isAnswer(loser)) {
43.                 winner = loser;
44.                 break;
45.             }
46.         }
47.         if(generation == max_generation)
48.             System.out.println("没找到合适的结果");
49.         else
50.             System.out.println("在第"+generation+"代"+parseToString(winner));
51.     }
53.     /**
54.      * 将某个染色体解析为内容友好的字符串
55.      */
56.     private String parseToString(int chrom) {
57.         StringBuilder result = new StringBuilder();
58.         StringBuilder sum = new StringBuilder();
59.         StringBuilder prod = new StringBuilder();
60.         for(int i=0; i<chrom_length; i++) {
61.             if(population[chrom][i] == 0)
62.                 sum.append((i+1) + "+");
63.             else
64.                 prod.append((i+1) + "*");
65.         }
66.         sum.replace(sum.length()-1, sum.length(), "="+sum_tagart);
67.         prod.replace(prod.length()-1, prod.length(), "="+product_targart);
68.         result.append("找到了合适的纸牌组合，分别是：" + System.getProperty("line.separator"));
69.         result.append(sum.toString() + System.getProperty("line.separator"));
70.         result.append(prod.toString() + System.getProperty("line.separator"));
71.         
72.         return result.toString();
73.     }
75.     /**
76.      * 判断某个染色体是否就是最终答案
77.      */
78.     private boolean isAnswer(int chrom) {
79.         if(getFitness(chrom) == 0f) {
80.             return true;
81.         }
82.         return false;
83.     }
85.     /**
86.      * 对染色体进行变异
87.      */
88.     private void mutation(int chrom) {
89.         for(int i=0; i<chrom_length; i++) {
90.             if(rand.nextFloat()<mutation_rate) {
91.                 population[chrom][i] = (population[chrom][i]+1)%2;
92.             }
93.         }
94.     }
96.     /**
97.      * 将两个染色体进行杂交，winner不变，只修改loser
98.      */
99.     private void crossover(int winner, int loser) {
100.         for(int i=0; i<chrom_length; i++) {
101.             if(rand.nextFloat()<crossover_rate)
102.                 population[loser][i] = population[winner][i];
103.         }
104.     }
106.     /**
107.      * 取得第i个染色体的符合度，符合度越小越好
108.      */
109.     private float getFitness(int chrom) {
110.         int sum = 0;
111.         int prod = 1;
112.         for(int i=0; i<chrom_length; i++) {
113.             if(population[chrom][i]==0)
114.                 sum += (1+i);
115.             else
116.                 prod *= (1+i);
117.         }
118.         return (float)Math.abs(sum - sum_tagart)/sum_tagart + (float)Math.abs(prod - product_targart)/product_targart;
119.     }
121.     /**
122.      * 初始化人口池，数组的内容为0或者1，
123.      * 0标识该扑克牌被分配到求和组
124.      * 1标识该扑克牌被分配到求积组
125.      */
126.     private void initPopuation(int[][] population2) {
127.         for(int i=0; i<pop_size; i++)
128.             for(int j=0; j<chrom_length; j++) {
129.                 if(rand.nextFloat()<0.5f)
130.                     population[i][j] = 0;
131.                 else
132.                     population[i][j] = 1;
133.             }
134.         
135.     }
136. }