遗传算法实现机器人寻路

package com.louis.robot;


/**
 * Project Name:GeneticAlgorithm
 * File Name:Individual.java
 * Package Name:
 * Date:2017年9月23日下午5:02:00
 * Copyright (c) 2017, 2692613726@qq.com All Rights Reserved.
 *
 */

/**
 * ClassName:Individual 
 * Function: 个体类
 * Reason:     TODO ADD REASON. 
 * Date:     2017年9月23日 下午5:02:00 
 * @author   michael
 * @version  
 * @since    JDK 1.7
 * @see      
 */
public class Individual {
    //定义染色体，染色体是要很多基因组成
    private int[] chromosome;
    //定义个体实现度，默认值是-1
    private double fitness = -1;
    /*
     * 通过特定染色体创建个体
     * */
    public Individual(int[] chromosome){
        this.chromosome = chromosome;
    }
    /*
     * 通过随机基因创建个体:染色上的基因是随机数产生的
     * */
    public Individual(int chromosomeLength){
        this.chromosome = new int[chromosomeLength];
        for (int gene = 0; gene < chromosomeLength; gene++) {
            if(0.5<Math.random()){
                this.setGene(gene, 1);
            }
            else {
                this.setGene(gene, 0);
            }
        }
    }
    /*
     * get 个体的基因
     * */
    public int[] getChromosome(){
        return this.chromosome;
    }
    
    /*
     * get 基因的长度
     * */
    public int getChromosomeLength(){
        return this.chromosome.length;
    }
    /*
     * 在特定的地方设置基因
     * */
    public void setGene(int offset,int gene){
        this.chromosome[offset] = gene;
    }
    
    /*
     * 在特定的地方得到基因
     * */
    public int getGene(int offset){
        return this.chromosome[offset];
    }
    /*
     * 设置个体适应度
     * */
    public void setFitness(double fitness){
        this.fitness = fitness;
    }
    /*
     * 得到个体适应度
     * */
    public double getFitness(){
        return this.fitness;
    } 
    /*
     * 染色体（即所有基因）以字符串的形式打印
     * */
    public String toString(){
        String output = "";
        for (int gene = 0; gene < this.chromosome.length; gene++) {
            output +=this.chromosome[gene];
        }
        return output;
    }
}

package com.louis.robot;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

import org.apache.jasper.tagplugins.jstl.core.If;



/**

 * Project Name:GeneticAlgorithm
 * File Name:Population.java
 * Package Name:
 * Date:2017年9月23日下午7:44:55
 * Copyright (c) 2017, 2692613726@qq.com All Rights Reserved.
 *
 */

/**
 * ClassName:Population 
 * Function: 种群类 
 * Reason:     TODO ADD REASON. 
 * Date:     2017年9月23日 下午7:44:55 
 * @author   michael
 * @version  
 * @since    JDK 1.7
 * @see      
 */
public class Population {
    //种群：所有个体的集合
    public Individual[] population;
    //种群适应度
    public double populationFitness=-1;
    /*
     * 初始化一个空的种群，参数是种群的大小
     * */
    public Population(int populationSize){
        this.population = new Individual[populationSize];
    }
    /*
     * 初始化种群，参数是：（1）种群的大小，（2）染色体的长度
     * */
    public Population(int populationSize,int chromosomeLength){
        //新建一个种群，即所有个体的集合
        this.population = new Individual[populationSize];
        //创建种群中的每个个体
        for (int individualCount = 0; individualCount < populationSize; individualCount++) {
            //调用Individual类的构造方法，创建个体
            Individual individual = new Individual(chromosomeLength);
            //将该个体添加到种群中
            this.population[individualCount] = individual;
        }
    }
    /*
     * 从种群中得到所有个体
     * */
    public Individual[] getIndividuals(){
        return this.population;
    }
    /*
     *通过个体适应度选择一个个体
     *先将种群进行排序，最后获得第offset位置的个体
     *按适应度顺序排列个体   
     *从高到底排序
     * */
    public Individual getFittest(int offset){
        //对种群中的个体按照适应度进行排序
        Arrays.sort(this.population, new Comparator<Individual>() {

            @Override
            public int compare(Individual o1, Individual o2) {
                if(o1.getFitness()>o2.getFitness()){
                    return -1;
                }
                else if(o1.getFitness()<o2.getFitness()){
                    return 1;
                }
                return 0;
            }   //Arrays.sort（数组，比较器<数组类型>）
            
        });
        //返回排序第offset的个体
        return this.population[offset];
    }
    /*
     * 得到种群适应度
     * */
    public double getPopulationFitness() {
        return populationFitness;
    }
    
    /*
     * 设置种群适应度
     * */
    public void setPopulationFitness(double populationFitness) {
        this.populationFitness = populationFitness;
    }
    /*
     * 得到种群的大小
     * */
    public int size(){
        return this.population.length;
    }
    /*
     * 在第offset位置设置个体
     * */
    public Individual setIndividual(int offset,Individual individual){
        return population[offset] = individual;
    }
    /*
     * 得到第offset位置的个体
     * */
    public Individual getIndividual(int offset){
        return population[offset];
    }
    /*
     * 随机洗牌
     * */
    public void shuffle() {
        Random rnd = new Random();
        for (int i = population.length - 1; i > 0; i--) {
            int index = rnd.nextInt(i + 1);
            Individual a = population[index];
            population[index] = population[i];
            population[i] = a;
        }
    }
}

/**
 * Project Name:GeneticAlgorithm
 * File Name:Maze.java
 * Package Name:com.louis.rebot
 * Date:2017年9月24日上午9:38:37
 * Copyright (c) 2017, 2692613726@qq.com All Rights Reserved.
 *
*/

package com.louis.robot;

import java.util.ArrayList;

/**
 * ClassName:Maze 
 * Function: 迷宫类
 * Reason:     
 * 0 = Empty 
 * 1 = Wall 
 * 2 = Starting position 
 * 3 = Route 
 * 4 = Goal position 
 * Date:     2017年9月24日 上午9:38:37 
 * @author   michael
 * @version  
 * @since    JDK 1.7
 * @see      
 */
public class Maze {
    private final int maze[][];
    private int startPosition[] = {-1,-1};
    
    public Maze(int maze[][]){
        this.maze = maze;
    }
    /*
     * 得到起始位置
     * */
    public int[] getStartPosition(){
        //确认已经找到起始位置
        if(this.startPosition[0]!=-1&&this.startPosition[1]!=-1){
            return this.startPosition;
        }
        //返回默认值
        int startPosition[] = {0,0};
        //遍历
        for (int rowIndex = 0; rowIndex < this.maze.length; rowIndex++) {
            for (int colIndex = 0; colIndex < this.maze[rowIndex].length; colIndex++) {
                //找坐标值是2的坐标
                if(this.maze[rowIndex][colIndex]==2){
                    this.startPosition = new int[]{colIndex,rowIndex};
                    return new int[]{colIndex,rowIndex};
                }
            }
        }
        return startPosition;
    }
    
    /*
     * 得到具体位置上的值
     * */
    public int getPositionValue(int x,int y){
        //在指定范围以外的坐标值为1，即是墙
        if(x<0||y<0||x>=this.maze.length||y>=this.maze[0].length){
            return 1;
        }
        return this.maze[y][x];
    }
    
    /*
     * 判断是否是墙
     * */
    public boolean isWall(int x,int y){
        return (this.getPositionValue(x, y)==1);
    }
    
    /*
     * 得到x的最大值，列数-1
     * */
    public int getMaxX(){
        return this.maze[0].length-1;
    }
    /*
     * 得到y的最大值，行数-1
     * */
    public int getMaxY(){
        return this.maze.length-1;
    }
    /*
     * 评估采取的路径，基于踩到的正确地砖的数目
     * route是路线，Arrlist类型，里面的数组代表的是经过的坐标点
     * */
    public int scoreRoute(ArrayList<int[]> route){
        int score = 0;
        boolean visited[][] = new boolean[this.getMaxY()+1][this.getMaxX()+1];
        for(Object routeStep:route){
            int step[] = (int[])routeStep;
            if(this.maze[step[1]][step[0]]==3 && visited[step[1]][step[0]]==false){
                score++;
                //已经访问过
                visited[step[1]][step[0]] = true;
            }
        }
        return score;
    }
}

/**
 * Project Name:GeneticAlgorithm
 * File Name:Robot.java
 * Package Name:com.louis.rebot
 * Date:2017年9月24日上午9:38:50
 * Copyright (c) 2017, 2692613726@qq.com All Rights Reserved.
 *
*/

package com.louis.robot;

import java.util.ArrayList;





/**
 * ClassName:Robot 
 * Function: 机器人类
 * Reason:     TODO ADD REASON. 
 * Date:     2017年9月24日 上午9:38:50 
 * @author   michael
 * @version  
 * @since    JDK 1.7
 * @see      
 */
public class Robot {
    //定义方向
    private enum Direction{NORTH,EAST,SOUTH,WEST};
    
    private int xPosition;
    private int yPosition;
    //下一步前往的方向
    private Direction heading;
    //最大移动步数
    int maxMoves;
    //当前移动了多少步
    int moves;
    //传感器的值
    private int sensorVal;
    //传感器行为数组
    private final int sensorActions[];
    //迷宫
    private Maze maze;
    //行走路线
    private ArrayList<int[]> route;
    public Robot(int[] sensorActions, Maze maze, int maxMoves){
        this.sensorActions = this.calcSensorActions(sensorActions);
        this.maze = maze;
        int startPos[] = this.maze.getStartPosition();
        this.xPosition = startPos[0];
        this.yPosition = startPos[1];
        this.sensorVal = -1;
        this.heading = Direction.EAST;
        this.maxMoves = maxMoves;
        this.moves = 0;
        this.route = new ArrayList<int[]>();
        this.route.add(startPos);
    }
    //基于传感器的输入运行机器人的行为
    public void run(){
        while(true){
            this.moves++;
            
            //机器人的下一步移动到为0
             if (this.getNextAction() == 0) {
                return;
            }
            //如果到达目的地
            if (this.maze.getPositionValue(this.xPosition, this.yPosition) == 4) {
                return;
            }
            //如果步数大于最大步数
            if (this.moves > this.maxMoves) {
                return;
            }
            //继续往前走
            this.makeNextAction();    
        }
    }
    /*
     * 将字符串类型的传感器数据映射成行为
     * */
    private int[] calcSensorActions(int[] sensorActionsStr){
        //多少个动作：一个动作，需要两位传感器数据
        int numActions = (int)sensorActionsStr.length/2;
        int sensorActions[] = new int[numActions];
        
        for (int sensorValue = 0; sensorValue < numActions; sensorValue++){
            //每次循环，sensorAtion都初始化为0
            int sensorAction = 0;
            if (sensorActionsStr[sensorValue*2] == 1){
                sensorAction += 2;
            }
            if (sensorActionsStr[(sensorValue*2)+1] == 1){
                sensorAction += 1;
            }
            
            //加入到行为数组中
            sensorActions[sensorValue] = sensorAction;
        }
         return sensorActions;
    }
    
    /*
     * 下一步执行什么操作
     * */
    public void makeNextAction(){
        // 向前移动
        if (this.getNextAction() == 1) {
            int currentX = this.xPosition;
            int currentY = this.yPosition;
            
            // 向前移动取决于当前的机器人面朝哪
            if (Direction.NORTH == this.heading) {
                this.yPosition += -1;
                if (this.yPosition < 0) {
                    this.yPosition = 0;
                }
            }
            else if (Direction.EAST == this.heading) {
                this.xPosition += 1;
                if (this.xPosition > this.maze.getMaxX()) {
                    this.xPosition = this.maze.getMaxX();
                }
            }
            else if (Direction.SOUTH == this.heading) {
                this.yPosition += 1;
                if (this.yPosition > this.maze.getMaxY()) {
                    this.yPosition = this.maze.getMaxY();
                }
            }
            else if (Direction.WEST == this.heading) {
                this.xPosition += -1;
                if (this.xPosition < 0) {
                    this.xPosition = 0;
                }
            }
            
            // 不能移动
            if (this.maze.isWall(this.xPosition, this.yPosition) == true) {
                this.xPosition = currentX;
                this.yPosition = currentY;
            } 
            else {
                if(currentX != this.xPosition || currentY != this.yPosition) {
                    this.route.add(this.getPosition());
                }
            }
        }
        // 顺时针移动
        else if(this.getNextAction() == 2) {
            if (Direction.NORTH == this.heading) {
                this.heading = Direction.EAST;
            }
            else if (Direction.EAST == this.heading) {
                this.heading = Direction.SOUTH;
            }
            else if (Direction.SOUTH == this.heading) {
                this.heading = Direction.WEST;
            }
            else if (Direction.WEST == this.heading) {
                this.heading = Direction.NORTH;
            }
        }
        // 逆时针移动
        else if(this.getNextAction() == 3) {
            if (Direction.NORTH == this.heading) {
                this.heading = Direction.WEST;
            }
            else if (Direction.EAST == this.heading) {
                this.heading = Direction.NORTH;
            }
            else if (Direction.SOUTH == this.heading) {
                this.heading = Direction.EAST;
            }
            else if (Direction.WEST == this.heading) {
                this.heading = Direction.SOUTH;
            }
        }
        
        // 重新设置传感器的值
        this.sensorVal = -1;
    }
    
    /*
     * 得到下一步的操作
     * */
    public int getNextAction() {
        return this.sensorActions[this.getSensorValue()];
    }
    
    /*
     * 得到传感器的值
     * */
    public int getSensorValue(){
        // If sensor value has already been calculated
        if (this.sensorVal > -1) {
            return this.sensorVal;
        }
                
        boolean frontSensor, frontLeftSensor, frontRightSensor, leftSensor, rightSensor, backSensor;
        frontSensor = frontLeftSensor = frontRightSensor = leftSensor = rightSensor = backSensor = false;

        // 机器人是朝哪个方向走的
        if (this.getHeading() == Direction.NORTH) {
            frontSensor = this.maze.isWall(this.xPosition, this.yPosition-1);
            frontLeftSensor = this.maze.isWall(this.xPosition-1, this.yPosition-1);
            frontRightSensor = this.maze.isWall(this.xPosition+1, this.yPosition-1);
            leftSensor = this.maze.isWall(this.xPosition-1, this.yPosition);
            rightSensor = this.maze.isWall(this.xPosition+1, this.yPosition);
            backSensor = this.maze.isWall(this.xPosition, this.yPosition+1);
        }
        else if (this.getHeading() == Direction.EAST) {
            frontSensor = this.maze.isWall(this.xPosition+1, this.yPosition);
            frontLeftSensor = this.maze.isWall(this.xPosition+1, this.yPosition-1);
            frontRightSensor = this.maze.isWall(this.xPosition+1, this.yPosition+1);
            leftSensor = this.maze.isWall(this.xPosition, this.yPosition-1);
            rightSensor = this.maze.isWall(this.xPosition, this.yPosition+1);
            backSensor = this.maze.isWall(this.xPosition-1, this.yPosition);
        }
        else if (this.getHeading() == Direction.SOUTH) {
            frontSensor = this.maze.isWall(this.xPosition, this.yPosition+1);
            frontLeftSensor = this.maze.isWall(this.xPosition+1, this.yPosition+1);
            frontRightSensor = this.maze.isWall(this.xPosition-1, this.yPosition+1);
            leftSensor = this.maze.isWall(this.xPosition+1, this.yPosition);
            rightSensor = this.maze.isWall(this.xPosition-1, this.yPosition);
            backSensor = this.maze.isWall(this.xPosition, this.yPosition-1);
        }
        else {
            frontSensor = this.maze.isWall(this.xPosition-1, this.yPosition);
            frontLeftSensor = this.maze.isWall(this.xPosition-1, this.yPosition+1);
            frontRightSensor = this.maze.isWall(this.xPosition-1, this.yPosition-1);
            leftSensor = this.maze.isWall(this.xPosition, this.yPosition+1);
            rightSensor = this.maze.isWall(this.xPosition, this.yPosition-1);
            backSensor = this.maze.isWall(this.xPosition+1, this.yPosition);
        }
                
        // Calculate sensor value
        int sensorVal = 0;
        
        if (frontSensor == true) {
            sensorVal += 1;
        }
        if (frontLeftSensor == true) {
            sensorVal += 2;
        }
        if (frontRightSensor == true) {
            sensorVal += 4;
        }
        if (leftSensor == true) {
            sensorVal += 8;
        }
        if (rightSensor == true) {
            sensorVal += 16;
        }
        if (backSensor == true) {
            sensorVal += 32;
        }

        this.sensorVal = sensorVal;

        return sensorVal;
    }
    
    /*
     * 返回机器人行走路径
     * */
    public ArrayList<int[]> getRoute(){       
        return this.route;
    }
    /*
     * 获取机器人坐标
     * */
    public int[] getPosition(){
        return new int[]{this.xPosition, this.yPosition};
    }
    /*
     * 机器人下一个方向
     * */
     private Direction getHeading(){
        return this.heading;
     }
     /*
      * 打印机器人行走路径
      * */
    public String printRoute() {
        String route = "";

        for (Object routeStep : this.route) {
            int step[] = (int[]) routeStep;
            route += "{" + step[0] + "," + step[1] + "}";
        }
        return route;
    }
}

package com.louis.robot;


import com.sun.org.apache.bcel.internal.generic.PopInstruction;

/**
 * Project Name:GeneticAlgorithm
 * File Name:GeneticAlgorithm.java
 * Package Name:
 * Date:2017年9月23日下午8:25:25
 * Copyright (c) 2017, 2692613726@qq.com All Rights Reserved.
 *
 */

/**
 * ClassName:GeneticAlgorithm 
 * Function: 遗传算法的核心
 * Reason:     TODO ADD REASON. 
 * Date:     2017年9月23日 下午8:25:25 
 * @author   michael
 * @version  
 * @since    JDK 1.7
 * @see      
 */
public class GeneticAlgorithm {
    /*种群大小*/
    private int populationSize;
    /*变异概率*/
    private double mutationRate;
    /*交叉概率*/
    private double crossoverRate;
    /*精英个体数：种群中最强的个体数。保持原样，不参与交叉和变异*/
    private int elitismCount;
    //锦标大小
    private int tournamentSize;
    /*构造函数*/
    public GeneticAlgorithm(int populationSize, double mutationRate,
            double crossoverRate, int elitismCount, int tournamentSize) {
        super();
        this.populationSize = populationSize;
        this.mutationRate = mutationRate;
        this.crossoverRate = crossoverRate;
        this.elitismCount = elitismCount;
        this.tournamentSize = tournamentSize;
    }
    /*
     * 调用population的构造方法，使用染色体长度初始化种群
     * */
    public Population initPopulation(int chromosomeLength){
        Population population = new Population(this.populationSize, chromosomeLength);
        return population;
    }

    /*
     * 计算一个个体的适应度
     * */
    public double calcFitness(Individual individual, Maze maze) {
        // 得到个体基因
        int[] chromosome = individual.getChromosome();

        // 得到适应度
        Robot robot = new Robot(chromosome, maze, 100);
        robot.run();
        int fitness = maze.scoreRoute(robot.getRoute());

        // 保存适应度
        individual.setFitness(fitness);

        return fitness;
    }

    /*
     * 遍历每个个体评估种群适应度
     * */
    public void evalPopulation(Population population, Maze maze) {
        double populationFitness = 0;

        //遍历每个个体统计种群总适应度
        for (Individual individual : population.getIndividuals()) {
            populationFitness += this.calcFitness(individual, maze);
        }

        population.setPopulationFitness(populationFitness);
    }
    /*
     * 判断终止的条件，最大代数
     * */
    public boolean isTerminationConditionMet(int generationsCount, int maxGenerations) {
        return (generationsCount > maxGenerations);
    }
    /*
     * 选择交叉的个体
     * */
    public Individual selectParent(Population population) {
        // 创建用于锦标赛的种群
        Population tournament = new Population(this.tournamentSize);

        //随机洗牌
        population.shuffle();
        // 随机向锦标赛插入个体
        for (int i = 0; i < this.tournamentSize; i++) {
            Individual tournamentIndividual = population.getIndividual(i);
            tournament.setIndividual(i, tournamentIndividual);
        }
        // 返回最好的个体
        return tournament.getFittest(0);
    }
    /*
     * 单点交叉：返回一个新的种群
     * */
    public Population crossoverPopulation(Population population) {
        // 重新创建一个种群
        Population newPopulation = new Population(population.size());

        // 按适应度遍历原来的种群
        for (int populationIndex = 0; populationIndex < population.size(); populationIndex++) {
            //因为已经按照适应度对种群进行排序了，所以这里是从小往大选择
            Individual parent1 = population.getFittest(populationIndex);

            // 是否交叉，交叉率大于随机数并且pass掉精英个体
            if (this.crossoverRate > Math.random() && populationIndex >= this.elitismCount) {
                // 初始化下一代个体
                Individual offspring = new Individual(parent1.getChromosomeLength());
                
                // 通过锦标赛选择第二个父个体
                Individual parent2 = this.selectParent(population);

                // 随机产生交叉点
                int swapPoint = (int) (Math.random() * (parent1.getChromosomeLength() + 1));

                for (int geneIndex = 0; geneIndex < parent1.getChromosomeLength(); geneIndex++) {
                    // 在交叉点前用1的基因，交叉点后用2的
                    if (geneIndex < swapPoint) {
                        offspring.setGene(geneIndex, parent1.getGene(geneIndex));
                    } else {
                        offspring.setGene(geneIndex, parent2.getGene(geneIndex));
                    }
                }

                // 将子个体加入到种群中
                newPopulation.setIndividual(populationIndex, offspring);
            } else {
                // 没有交叉的个体直接加入到种群中，精英个体
                newPopulation.setIndividual(populationIndex, parent1);
            }
        }

        return newPopulation;
    }
    
    /*变异得到新种群*/
    public Population mutatePopulation(Population population){
        Population newPopulation = new Population(this.populationSize);
        //通过适应度遍历当前种群
        for (int populationIndex = 0; populationIndex < population.size(); populationIndex++) {
            //按照从小到大的顺序选择个体
            Individual individual = population.getFittest(populationIndex);
            //遍历个体的基因
            for (int geneIndex = 0; geneIndex < individual.getChromosomeLength(); geneIndex++) {
                if(populationIndex>this.elitismCount){
                    //判断该基因是否变异
                    if(this.mutationRate>Math.random()){
                        int newGene = 1;
                        if(individual.getGene(geneIndex)==1){
                            newGene = 0;
                        }
                        //变异基因
                        individual.setGene(geneIndex, newGene);
                    }
                    
                }
            }
            newPopulation.setIndividual(populationIndex, individual);
        }
        return newPopulation;
    }
    
}

/**
 * Project Name:GeneticAlgorithm
 * File Name:RobotController.java
 * Package Name:com.louis.robot
 * Date:2017年9月24日上午9:39:50
 * Copyright (c) 2017, 2692613726@qq.com All Rights Reserved.
 *
*/

package com.louis.robot;



/**
 * ClassName:RobotController 
 * Function: 执行类
 * Reason:     TODO ADD REASON. 
 * Date:     2017年9月24日 上午9:39:50 
 * @author   michael
 * @version  
 * @since    JDK 1.7
 * @see      
 */
public class RobotController {
    //设置最大的代
    public static int maxGenerations = 1000;
    
    public static void main(String[] args) {
        //创建迷宫
        Maze maze = new Maze(new int[][] { 
                { 0, 0, 0, 0, 1, 0, 1, 3, 2 }, 
                { 1, 0, 1, 1, 1, 0, 1, 3, 1 },
                { 1, 0, 0, 1, 3, 3, 3, 3, 1 }, 
                { 3, 3, 3, 1, 3, 1, 1, 0, 1 }, 
                { 3, 1, 3, 3, 3, 1, 1, 0, 0 },
                { 3, 3, 1, 1, 1, 1, 0, 1, 1 }, 
                { 1, 3, 0, 1, 3, 3, 3, 3, 3 }, 
                { 0, 3, 1, 1, 3, 1, 0, 1, 3 },
                { 1, 3, 3, 3, 3, 1, 1, 1, 4 } 
        });
        
        //创建遗传算法
        GeneticAlgorithm ga = new GeneticAlgorithm(200, 0.05, 0.9, 2, 10);
        Population population = ga.initPopulation(128);
        
        /*
         * 评估种群
         * */
        ga.evalPopulation(population, maze);
        
        int generation =1;
        
        /*
         * 开始进化
         * */
        while (ga.isTerminationConditionMet(generation, maxGenerations) == false) {
            // 打印种群中适应度最好的个体
            Individual fittest = population.getFittest(0);
            System.out.println("G" + generation + " Best solution ("
                    + fittest.getFitness() + "): " + fittest.toString());

            // 交叉
            population = ga.crossoverPopulation(population);

            // 变异
            population = ga.mutatePopulation(population);

            // 评估种群
            ga.evalPopulation(population, maze);

            // 迭代
            generation++;
        }

        System.out.println("Stopped after " + maxGenerations + " generations.");
        Individual fittest = population.getFittest(0);
        System.out.println("Best solution (" + fittest.getFitness() + "): "
                + fittest.toString());

    }
    
}