遗传算法求解TSP及其变式

最新推荐文章于 2023-05-20 22:48:27 发布
最新推荐文章于 2023-05-20 22:48:27 发布
阅读量917 收藏 2
点赞数 1
分类专栏： 算法 文章标签： 遗传算法 TSP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42783170/article/details/96153032
版权 
	刚刚接触遗传算法，主要学习的是以下几位老师的文章（抱拳），链接附上：

https://blog.csdn.net/u010451580/article/details/51178225
https://blog.csdn.net/wangqiuyun/article/details/12838903

写这篇文章主要是系统地整理一下我这几天学到了算法，所以内容不多。

1.遗传算法简介

遗传算法（Genetic Algorithm, GA）起源于对生物系统所进行的计算机模拟研究。它是模仿自然界生物进化机制发展起来的随机全局搜索和优化方法，借鉴了达尔文的进化论和孟德尔的遗传学说。
算法是将初始解构成初始种群，然后不断遗传、进化、变异，最终从中挑选出最优个体，应该算是基于大数据的。
有三种基本算子：选择，交叉，变异，

遗传算法的实施步骤如下（以目标函数求最小为例）。
第一步：初始化 t←0进化代数计数器；T是最大进化代数；随机生成M个个体作为初始群体P（t）；
第二步：个体评价 计算P（t）中各个个体的适应度；（即评估个体好坏的一个指标）
第三步：选择运算 将选择算子作用于群体；（类似于物竞天择，适者生存）
第四步：交叉运算 将交叉算子作用于群体；（两个体交叉繁殖出新个体）斜体样式
第五步：变异运算 将变异算子作用于群体，并通过以上运算得到下一代群体P（t + 1）;（自身变异形成新个体）
第六步：终止条件判断 t≦T：t← t+1 转到步骤2；t>T：终止 输出解。

常见的选择策略：
最常见的是赌轮选择方法，本质是个体被选中的概率与适应度成正比。这里选择的时候会用到累计概率，即计算出个体的适应度后，求出个体适应度占总适应度的一个比例，如个体1、个体2、个体3的适应度分别为f1,f2,f3,总适应度sumf = f1+f2+f3.则个体1、2、3的累计概率分别为f1/sumf, (f1+f2)/sumf, (f1+f2+f3)/sumf。最后一个数必然为1，则构成一个0-1的轮盘，随机数落在哪个范围，即选择对应个体作为新种群的一员。

那么具体如何选择，如何交叉？且看一下大神整理的：
https://www.cnblogs.com/legend1130/p/5333087.html
常见交叉策略：
https://blog.csdn.net/ztf312/article/details/82793295

其实感觉算法还是要结合一下具体事例（代码）一起看的，刚开始看算法似懂非懂，雾里看花的感觉，还是看了一遍别人写的具体代码才拨云见月。

2.具体应用——TSP问题

TSP问题（Travelling Salesman Problem）即旅行商问题，又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。
1、
基本思路：
1》初始化：随机生成scale条路径放入oldpopulation,（城市作为编号，编码表示路径。scale为种群的规模，每一条路径为一个个体）
2》算适应度：路径的长度越短，适应度（fitness）最高
3》挑选出适应度最高的路径放入newpopulation,若优于之前的best_tour,则更新best_tour
4》计算种群中个个体的累计概率，用赌轮选择法挑选出下一代放入newpopulation
5》对newpopulation进行交叉
6》对newpopulation进行变异
7》将newpopulation—>oldpopulation,
8》将重复进行2-7

代码附上：（和wangqiuyun博主不同的是我的代码所需数据是自己给的（也可自己文件读写），八个城市的距离矩阵（无向图，所以是对称矩阵）

private int[][] distance =
{{0, 300, 360, 210, 590, 475 , 500, 690},
{300, 0 ,380, 270, 230, 285, 200, 390},
{360, 380, 0 ,510 ,230, 765, 580, 770},
{210, 270 , 510, 0, 470, 265, 450, 640},
{590, 230, 230, 470 ,0, 515 , 260, 450},
{475, 285, 765, 265, 515, 0 ,460, 650},
{500, 200 , 580 , 450 ,260 ,460 ,0 ,190},
{690, 390 ,770, 640 ,450, 650 ,190, 0}}; ）


import java.io.BufferedReader;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.util.Random;  
 
public class GA {  
  
    private int scale;// 种群规模  
    private int cityNum; // 城市数量，染色体长度  
    private int MAX_GEN; // 运行代数 
    private int start = 0;
    private int end = 7;
  
   private int[][] distance = 
    	    {{0,   300,  360,   210,    590,    475	,   500,	690},
    		{10000,	0	,380,	270,	230,	285,	200,	390},
    		{10000,	380,	0	,510	,230,	765,	580,	770},
    		{10000,	270	, 510,	 0,	    470,	265,	450,	640},
    		{10000,	230,  230,   470	,0,	    515	,   260,	450},
    		{10000,	285,   765,	 265,	515,	0	,460,	650},
    		{10000,	200	,  580	, 450	,260	,460	,0	,190},
    		{10000,	10000	,10000,	10000	,10000,	10000	,10000,	0}}; // 距离矩阵 */ 
    private int bestT;// 最佳出现代数  
    private int bestLength; // 最佳长度  
    private int[] bestTour; // 最佳路径  
  
    // 初始种群，父代种群，行数表示种群规模，一行代表一个个体，即染色体，列表示染色体基因片段  
    private int[][] oldPopulation;  
    private int[][] newPopulation;// 新的种群，子代种群  
    private int[] fitness;// 种群适应度，表示种群中各个个体的适应度  
  
    private float[] Pi;// 种群中各个个体的累计概率  
    private float Pc;// 交叉概率  
    private float Pm;// 变异概率  
    private int t;// 当前代数  
  
    
    private Random random;  
  
    public GA() {  
  
    }  
  
    /** 
     * constructor of GA 
     *  
     * @param s 
     *            种群规模 
     * @param n 
     *            城市数量 
     * @param g 
     *            运行代数 
     * @param c 
     *            交叉率 
     * @param m 
     *            变异率 
     *  
     **/  
    public GA(int s, int n, int g, float c, float m) {  
        scale = s;  
        cityNum = n;  
        MAX_GEN = g;  
        Pc = c;  
        Pm = m;  
    }  
  
    // 给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默  
    @SuppressWarnings("resource")  
    /** 
     * 初始化GA算法类 
     * @param filename 数据文件名，该文件存储所有城市节点坐标数据 
     * @throws IOException 
     */  
    private void init(String filename) throws IOException {  
        // 读取数据  
        /*int[] x;  
        int[] y;  
        String strbuff;  
        BufferedReader data = new BufferedReader(new InputStreamReader(  
                new FileInputStream(filename)));  
        distance = new int[cityNum][cityNum];  
        x = new int[cityNum];  
        y = new int[cityNum];  
        for (int i = 0; i < c ityNum; i++) {  
            // 读取一行数据，数据格式1 6734 1453  
            strbuff = data.readLine();  
            // 字符分割  
            String[] strcol = strbuff.split(" ");  
            x[i] = Integer.valueOf(strcol[1]);// x坐标  
            y[i] = Integer.valueOf(strcol[2]);// y坐标  
        }  
        // 计算距离矩阵  
        // ，针对具体问题，距离计算方法也不一样，此处用的是att48作为案例，它有48个城市，距离计算方法为伪欧氏距离，最优值为10628  
        for (int i = 0; i < cityNum - 1; i++) {  
            distance[i][i] = 0; // 对角线为0  
            for (int j = i + 1; j < cityNum; j++) {  
                double rij = Math  
                        .sqrt(((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j])  
                                * (y[i] - y[j])) / 10.0);  
                // 四舍五入，取整  
                int tij = (int) Math.round(rij);  
                if (tij < rij) {  
                    distance[i][j] = tij + 1;  
                    distance[j][i] = distance[i][j];  
                } else {  
                    distance[i][j] = tij;  
                    distance[j][i] = distance[i][j];  
                }  
            }  
        }  
        distance[cityNum - 1][cityNum - 1] = 0;  */
    			
        bestLength = Integer.MAX_VALUE;  
        bestTour = new int[cityNum + 1];  
        bestT = 0;  
        t = 0;  
  
        newPopulation = new int[scale][cityNum];  
        oldPopulation = new int[scale][cityNum];  
        fitness = new int[scale];  
        Pi = new float[scale];  
  
        random = new Random(System.currentTimeMillis());  
        /* 
         * for(int i=0;i<cityNum;i++) { for(int j=0;j<cityNum;j++) { 
         * System.out.print(distance[i][j]+","); } System.out.println(); } 
         */  
        // 初始化种群  
  
    }  
  
    // 初始化种群  
    void initGroup() {  
        int i, j, k;  
        // Random random = new Random(System.currentTimeMillis());  
        for (k = 0; k < scale; k++)// 种群数  
        {  
            oldPopulation[k][0] = random.nextInt(65535) % cityNum;  
            for (i = 1; i < cityNum;)// 染色体长度  
            {  
                oldPopulation[k][i] = random.nextInt(65535) % cityNum;  
                for (j = 0; j < i; j++) {  
                    if (oldPopulation[k][i] == oldPopulation[k][j]) {  
                        break;  
                    }  
                }  
                if (j == i) {  
                    i++;  
                }  
            }  
        }  
  
        /* 
         * for(i=0;i<scale;i++) { for(j=0;j<cityNum;j++) { 
         * System.out.print(oldPopulation[i][j]+","); } System.out.println(); } 
         */  
    }  
    //返回路径长度
    public int evaluate(int[] chromosome) {  
        // 0123  
        int len = 0;  
        // 染色体，起始城市,城市1,城市2...城市n  
        for (int i = 1; i < cityNum; i++) {  
            len += distance[chromosome[i - 1]][chromosome[i]];  
        }  
        // 城市n,起始城市  
       // len += distance[chromosome[cityNum - 1]][chromosome[0]];  
        return len;  
    }  
  
    // 计算种群中各个个体的累积概率，前提是已经计算出各个个体的适应度fitness[max]，作为赌轮选择策略一部分，Pi[max]  
    void countRate() {  
        int k;  
        double sumFitness = 0;// 适应度总和  
  
        double[] tempf = new double[scale];  
  
        for (k = 0; k < scale; k++) {  
            tempf[k] = 10.0 / fitness[k];  //适应度越小，temp越大，即temp与长度成反比
            sumFitness += tempf[k];  
        }  
  
        Pi[0] = (float) (tempf[0] / sumFitness);  
        for (k = 1; k < scale; k++) {  
            Pi[k] = (float) (tempf[k] / sumFitness + Pi[k - 1]);  //累积概率
        }  
  
        /* 
         * for(k=0;k<scale;k++) { System.out.println(fitness[k]+" "+Pi[k]); } 
         */  
    }  
  
    // 挑选某代种群中适应度最高的个体，直接复制到子代中 （即路径长度的值最低） 
    // 前提是已经计算出各个个体的适应度Fitness[max]  
    public void selectBestGh() {  
        int k, i, maxid;  
        int maxevaluation;  
  
        maxid = 0;  
        maxevaluation = fitness[0];  
        for (k = 1; k < scale; k++) {  
            if (maxevaluation > fitness[k]) {  
                maxevaluation = fitness[k];  
                maxid = k;  
            }  
        }  
  
        if (bestLength > maxevaluation) {  
            bestLength = maxevaluation;  
            bestT = t;// 最好的染色体出现的代数;  
            for (i = 0; i < cityNum; i++) {  
                bestTour[i] = oldPopulation[maxid][i];  
            }  
        }  
  
        // System.out.println("代数 " + t + " " + maxevaluation);  
        // 复制染色体，k表示新染色体在种群中的位置，kk表示旧的染色体在种群中的位置  
        copyGh(0, maxid);// 将当代种群中适应度最高的染色体k复制到新种群中，排在第一位0  
    }  
  
    // 复制染色体，k表示新染色体在种群中的位置，kk表示旧的染色体在种群中的位置  
    public void copyGh(int k, int kk) {  
        int i;  
        for (i = 0; i < cityNum; i++) {  
            newPopulation[k][i] = oldPopulation[kk][i];  
        }  
    }  
  
    // 赌轮选择策略挑选  
    public void select() {  
        int k, i, selectId;  
        float ran1;  
        // Random random = new Random(System.currentTimeMillis());  
        for (k = 1; k < scale; k++) {  
        	ran1 = (float) (random.nextInt(65535) % 1000 / 1000.0);  
                // System.out.println("概率"+ran1);  
                // 产生方式  
            for (i = 0; i < scale; i++) {  
            	if (ran1 <= Pi[i]) {  
                        break;  
                }  
            }  
            selectId = i;  
                // System.out.println("选中" + selectId);  
            copyGh(k, selectId);
              
        }  
    }  
  
    //进化函数，正常交叉变异  
    public void evolution() {  
        int k;  
        // 挑选某代种群中适应度最高的个体  
        selectBestGh();  
  
        // 赌轮选择策略挑选scale-1个下一代个体  
        select();  
  
        // Random random = new Random(System.currentTimeMillis());  
        float r;  
  
        // 交叉方法  
        for (k = 0; k < scale; k = k + 2) {  
            r = random.nextFloat();// /产生概率  
            // System.out.println("交叉率..." + r);  
            if (r < Pc) {  
                // System.out.println(k + "与" + k + 1 + "进行交叉...");  
                //OXCross(k, k + 1);// 进行交叉  
                OXCross1(k, k + 1);  
            } else {  
                r = random.nextFloat();// /产生概率  
                // System.out.println("变异率1..." + r);  
                // 变异  
                if (r < Pm) {  
                    // System.out.println(k + "变异...");  
                    OnCVariation(k);  
                }  
                r = random.nextFloat();// /产生概率  
                // System.out.println("变异率2..." + r);  
                // 变异  
                if (r < Pm) {  
                    // System.out.println(k + 1 + "变异...");  
                    OnCVariation(k + 1);  
                }  
            }  
  
        }  
    }  
  
    //进化函数，保留最好染色体不进行交叉变异  
    public void evolution1() {  
        int k;  
        // 挑选某代种群中适应度最高的个体  
        selectBestGh();  
  
        // 赌轮选择策略挑选scale-1个下一代个体  
        select();  
  
        // Random random = new Random(System.currentTimeMillis());  
        float r;  
  
        for (k = 1; k + 1 < scale / 2; k = k + 2) {  
            r = random.nextFloat();// /产生概率  
            if (r < Pc) {  
                //OXCross1(k, k + 1);// 进行交叉  
                OXCross(k,k+1);//进行交叉  
            } else {  
                r = random.nextFloat();// /产生概率  
                // 变异  
                if (r < Pm) {  
                    OnCVariation(k);  
                }  
                r = random.nextFloat();// /产生概率  
                // 变异  
                if (r < Pm) {  
                    OnCVariation(k + 1);  
                }  
            }  
        }  
        if (k == scale / 2 - 1)// 剩最后一个染色体没有交叉L-1  
        {  
            r = random.nextFloat();// /产生概率  
            if (r < Pm) {  
                OnCVariation(k);  
            }  
        }  
  
    }  
  
    // 类OX交叉算子  
    void OXCross(int k1, int k2) {  
        int i, j, k, flag;  
        int ran1, ran2, temp;  
        int[] Gh1 = new int[cityNum];  
        int[] Gh2 = new int[cityNum];  
        // Random random = new Random(System.currentTimeMillis());  
  
        ran1 = random.nextInt(65535) % cityNum;  
        ran2 = random.nextInt(65535) % cityNum;  
        // System.out.println();  
        // System.out.println("-----------------------");  
        // System.out.println("----"+ran1+"----"+ran2);  
  
        while (ran1 == ran2) {  
            ran2 = random.nextInt(65535) % cityNum;  
        }  
  
        if (ran1 > ran2)// 确保ran1<ran2  
        {  
            temp = ran1;  
            ran1 = ran2;  
            ran2 = temp;  
        }  
        // System.out.println();  
        // System.out.println("-----------------------");  
        // System.out.println("----"+ran1+"----"+ran2);  
        // System.out.println("-----------------------");  
        // System.out.println();  
        flag = ran2 - ran1 + 1;// 删除重复基因前染色体长度  
        for (i = 0, j = ran1; i < flag; i++, j++) {  
            Gh1[i] = newPopulation[k2][j];  
            Gh2[i] = newPopulation[k1][j];  
        }  
        // 已近赋值i=ran2-ran1个基因  
  
        for (k = 0, j = flag; j < cityNum;)// 染色体长度  
        {  
            Gh1[j] = newPopulation[k1][k++];  
            for (i = 0; i < flag; i++) {  
                if (Gh1[i] == Gh1[j]) {  
                    break;  
                }  
            }  
            if (i == flag) {  
                j++;  
            }  
        }  
  
        for (k = 0, j = flag; j < cityNum;)// 染色体长度  
        {  
            Gh2[j] = newPopulation[k2][k++];  
            for (i = 0; i < flag; i++) {  
                if (Gh2[i] == Gh2[j]) {  
                    break;  
                }  
            }  
            if (i == flag) {  
                j++;  
            }  
        }  
  
        for (i = 0; i < cityNum; i++) {  
            newPopulation[k1][i] = Gh1[i];// 交叉完毕放回种群  
            newPopulation[k2][i] = Gh2[i];// 交叉完毕放回种群  
        }  
  
        // System.out.println("进行交叉--------------------------");  
        // System.out.println(k1+"交叉后...");  
        // for (i = 0; i < cityNum; i++) {  
        // System.out.print(newPopulation[k1][i] + "-");  
        // }  
        // System.out.println();  
        // System.out.println(k2+"交叉后...");  
        // for (i = 0; i < cityNum; i++) {  
        // System.out.print(newPopulation[k2][i] + "-");  
        // }  
        // System.out.println();  
        // System.out.println("交叉完毕--------------------------");  
    }  
  
    // 交叉算子,相同染色体交叉产生不同子代染色体  
    public void OXCross1(int k1, int k2) {  
        int i, j, k, flag;  
        int ran1, ran2, temp;  
        int[] Gh1 = new int[cityNum];  
        int[] Gh2 = new int[cityNum];  
        // Random random = new Random(System.currentTimeMillis());  
  
        ran1 = random.nextInt(65535) % cityNum;  
        ran2 = random.nextInt(65535) % cityNum;  
        while (ran1 == ran2) {  
            ran2 = random.nextInt(65535) % cityNum;  
        }  
  
        if (ran1 > ran2)// 确保ran1<ran2  
        {  
            temp = ran1;  
            ran1 = ran2;  
            ran2 = temp;  
        }  
  
        // 将染色体1中的第三部分移到染色体2的首部  
        for (i = 0, j = ran2; j < cityNum; i++, j++) {  
            Gh2[i] = newPopulation[k1][j];  
        }  
  
        flag = i;// 染色体2原基因开始位置  
  
        for (k = 0, j = flag; j < cityNum;)// 染色体长度  
        {  
            Gh2[j] = newPopulation[k2][k++];  
            for (i = 0; i < flag; i++) {  
                if (Gh2[i] == Gh2[j]) {  
                    break;  
                }  
            }  
            if (i == flag) {  
                j++;  
            }  
        }  
  
        flag = ran1;  
        for (k = 0, j = 0; k < cityNum;)// 染色体长度  
        {  
            Gh1[j] = newPopulation[k1][k++];  
            for (i = 0; i < flag; i++) {  
                if (newPopulation[k2][i] == Gh1[j]) {  
                    break;  
                }  
            }  
            if (i == flag) {  
                j++;  
            }  
        }  
  
        flag = cityNum - ran1;  
  
        for (i = 0, j = flag; j < cityNum; j++, i++) {  
            Gh1[j] = newPopulation[k2][i];  
        }  
  
        for (i = 0; i < cityNum; i++) {  
            newPopulation[k1][i] = Gh1[i];// 交叉完毕放回种群  
            newPopulation[k2][i] = Gh2[i];// 交叉完毕放回种群  
        }  
    }  
  
    // 多次对换变异算子  
    public void OnCVariation(int k) {  
        int ran1, ran2, temp;  
        int count;// 对换次数  
  
        // Random random = new Random(System.currentTimeMillis());  
        count = random.nextInt(65535) % cityNum;  
  
        for (int i = 0; i < count; i++) {  
  
            ran1 = random.nextInt(65535) % cityNum;  
            ran2 = random.nextInt(65535) % cityNum;  
            while (ran1 == ran2) {  
                ran2 = random.nextInt(65535) % cityNum;  
            }  
            temp = newPopulation[k][ran1];  
            newPopulation[k][ran1] = newPopulation[k][ran2];  
            newPopulation[k][ran2] = temp;  
        }  
  
        /* 
         * for(i=0;i<L;i++) { printf("%d ",newGroup[k][i]); } printf("\n"); 
         */  
    }  
  
    public void solve() {  
        int i;  
        int k;  
  
        // 初始化种群  
        initGroup();  
        // 计算初始化种群适应度，Fitness[max]  
        for (k = 0; k < scale; k++) {  
            fitness[k] = evaluate(oldPopulation[k]); //适应度即路径长度
           // if(oldPopulation[k][0] == start|| oldPopulation[k][7] == end)
            //	fitness[k] = -1;
            // System.out.println(fitness[k]);  
        }  
        // 计算初始化种群中各个个体的累积概率，Pi[max]  
        countRate();  
        System.out.println("初始种群...");  
        for (k = 0; k < scale; k++) {  
            for (i = 0; i < cityNum; i++) {  
                System.out.print(oldPopulation[k][i] + ",");  
            }  
            System.out.println();  
            System.out.println("----" + fitness[k] + " " + Pi[k]);  
        }  
          
        for (t = 0; t < MAX_GEN; t++) {  
            //evolution();  
            evolution1();  
            // 将新种群newGroup复制到旧种群oldGroup中，准备下一代进化  
            for (k = 0; k < scale; k++) {  
                for (i = 0; i < cityNum; i++) {  
                    oldPopulation[k][i] = newPopulation[k][i];  
                }  
            }  
            // 计算种群适应度  
            for (k = 0; k < scale; k++) {  
                fitness[k] = evaluate(oldPopulation[k]);  
               // if(oldPopulation[k][0] == start || oldPopulation[k][7] == end)
                //	fitness[k] =-1;
            }  
            // 计算种群中各个个体的累积概率  
            countRate();  
        }  
  
        System.out.println("最后种群...");  
        for (k = 0; k < scale; k++) {  
            for (i = 0; i < cityNum; i++) {  
                System.out.print(oldPopulation[k][i] + ",");  
            }  
            System.out.println();  
            System.out.println("---" + fitness[k] + " " + Pi[k]);  
        }  
  
        System.out.println("最佳长度出现代数：");  
        System.out.println(bestT);  
        System.out.println("最佳长度");  
        System.out.println(bestLength);  
        System.out.println("最佳路径：");  
        for (i = 0; i < cityNum; i++) {  
            System.out.print(bestTour[i] + ",");  
        }  
  
    }  
  
      
    /** 
     * @param args 
     * @throws IOException 
     */  
 
    public static void main(String[] args) throws IOException {  
        System.out.println("Start....");  
        GA ga = new GA(30, 8, 2000, 0.8f, 0.9f);  
        ga.init("c://data.txt");  
        ga.solve();  
    }  
  
}

2、TSP变式
如果出发点和终点固定，假设城市0位起点，城市7为终点，可将该路线图想象为有向图，所有城市均不能到达城市0，城市7不能不到达所有城市（都设为无穷大）,经过迭代后即可求出答案
距离矩阵
private int[][] distance =
{{0, 300, 360, 210, 590, 475 , 500, 690},
{10000, 0 ,380, 270, 230, 285, 200, 390},
{10000, 380, 0 ,510 ,230, 765, 580, 770},
{10000, 270 , 510, 0, 470, 265, 450, 640},
{10000, 230, 230, 470 ,0, 515 , 260, 450},
{10000, 285, 765, 265, 515, 0 ,460, 650},
{10000, 200 , 580 , 450 ,260 ,460 ,0 ,190},
{10000, 10000 ,10000, 10000 ,10000, 10000 ,10000, 0}}; // 距离矩阵 */
其余代码同上

3.有约束条件的遗传算法

TSP问题没有其他的约束条件，但对于求解一个多元函数，可能要求
0<x<100,y >x等等，这时候就需要考虑约束条件。
我看过几篇论文，关于这个问题有修复不可行解法，改变遗传算子法，惩罚函数法，我没有深入研究过。不过我做过一个题，是多约束条件的，用了罚函数来体现违反约束的程度，并对适应度进行相应惩罚，也得出了结果。
罚函数是通过对不可行解的惩罚将约束问题转化为无约束问题，任何对约束的违法都要在目标函数中添加惩罚项。这个未完待续……

暂时掌握，后期更新。若文章有误，还请指正，谢谢！

2019年7月16日 周二

coding随笔
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
matlab改进的遗传算法求解路径优化问题
03-28
所走路程的最短路径,其可能的路径数与城市个数成指数关系增长.目前应用遗传算法解决TSP问题,主要要解决编码问题和算子的设计问题.编码方式约束了运算空间的大小,好的编码方式可以压缩求解空间,提高运算效率.常见的编码方式有二进制编码,实值编码,自然编码等本文主要讨论**自然编码方式下算子的改进**及其MATLAB的程序实现.针对TSP问题,提出**贪婪交叉算子**和**倒位变异算子**来加快算法的收敛速度,同时又**不易陷入局部最优**,从而较好地解决了群体的多样性和收敛速度的予盾
基于遗传算法的TSP问题求解算法及其系统.pdf
11-23
基于遗传算法的TSP问题求解算法及其系统.pdf
MATLAB遗传算法解决旅行商问题（TSP）、多旅行商问题（MTSP）及其变体（共计39种情况）
07-30
MATLAB下，用遗传算法解决旅行商问题（TSP）、多旅行商问题（MTSP）及其变体（共计39种情况）的代码，具体说明详见README
TSP问题的遗传算法求解.zip
06-14
TSP问题的遗传算法求解 ,遗传算法（GeneticAlgorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，通过模拟自然进化过程搜索最优解。遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，初代种群产生之后，按照适者生存和优胜劣汰的原理，逐代（generation）演化产生出越来越好的近似解，在每一代，根据问题域中个体的适应度（fitness）大小选择个体，并借助于自然遗传学的遗传算子（geneticoperators）进行组合交叉（crossover）和变异（mutation），产生出代表新的解集的种群。这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于环境，末代种群中的最优个体经过解码（decoding），可以作为问题近似最优解。
论文研究-遗传算法及其在求解TSP中的应用 .pdf
08-16
遗传算法及其在求解TSP中的应用，郑伟，孙文生，讨论了遗传算法的基本原理，给出了采用遗传算法求解TSP问题的实例，并引入局部搜索机制。实验表明，本算法在城市规模较小时，能100
POJ 3329 TSP变形 / floyd预处理+状压DP
卡尔
06-02 770
TSP（旅行商问题）：n个点的图，从原点出发，每个点都走且仅走一次，最后回到原点，求最小花费的路径。 动态规划解TSP，要求点的数目一定要小于16。用一个16位的二进制数，每一位1表示走了，0表示没走。16位0、1的所有排列便可以穷尽16个点的所有路径。
【论文翻译】TSP-问题（4个变体）TRAVELLING-SALESMAN-PROBLEM (4 variants)
weixin_42754727的博客
11-12 988
给定一组城市（即点或顶点），TSP的目标是找到一个访问所有点的最小成本环形路线（或循环或巡回）。
基于遗传算法的TSP算法（附代码）
panmingqian的博客
01-08 8680
TSP (traveling salesman problem，旅行商问题)是典型的NP完全问题，即其最坏情况下的时间复杂度随着问题规模的增大按指数方式增长，到目前为止还未找到一个多项式时间的有效算法。 一、问题描述 本案例以14个城市为例，假定14个城市的位置坐标如表4 - 1所列。寻找出一条最短的遍历14个城市的路径。 二、解决思路及步骤 1、算法流程图 2、遗传算法实现及部分代码 （1）编码 采用整数排列编码方法。对于 ...
hdu 3001 Travelling TSP变形 三进制状压dp
TIMELIMITE的专栏
04-14 1014
// hdu 3001 TSP问题的变形 // 这次到每个点最多两次，所以可以用三进制的类推 // dp[S][u]表示当前在u点访问状态为S时所得到的最小的开销 // 采用刷表法，即用当前的状态推出它所能转移的状态 // dp[S][u] 可以到达的状态为dp[S+state[v]][v](dist[u][v]!=inf) // dp[S+state[v]][v] = max(dp[S+stat
TSP问题变异算法之交换变异
lfw198911的专栏
12-27 2908
交换变异exchange mutation 交换变异的变异过程详细演示
基于遗传算法求解TSP问题（JAVA）
wangqiuyun的专栏
10-17 5万+
一、TSP问题 TSP问题（Travelling Salesman Problem）即旅行商问题，又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。 TSP问题是一个组合优化问题。该问题可以被证明具有NP
TSP_旅行商问题 - 蛮力法DFS（一）
Houchaoqun_XMU的博客
01-16 2万+
本文基于蛮力法（此处采用深度优先遍历，DFS）解决旅行商问题。通过遍历出所有满足条件的路径情况，并保持更新最优解，直到所有情况都遍历完，得到全局最优解。但是，使用蛮力法需要遍历的城市个数高达city_num的阶乘，当city_num=12的时候，需遍历479001600种情况，程序所需时间以小时为单位。
遗传算法解决TSP问题
qq_43787814的博客
11-19 7773
一.原理及问题描述 1.遗传算法原理 遗传算法的概念简单来说，就是利用种群搜索技术将种群作为一组问题解，通过对当前种群施加类似生物遗传环境因素的选择、交叉、变异等一系列的遗传操作来产生新一代的种群，并逐步使种群优化到包含近似最优解的状态。 2.TSP问题描述 TSP问题，即旅行商问题，是指对于给定的n个城市，旅行商从某一城市出发不重复的访问其余城市后回到出发城市，要求找出一条路线，路程最短。 3....
【路径规划-TSP问题】基于遗传算法求解多旅行商问题不同起点和终点附matlab代码
m0_57702748的博客
05-20 197
旅行商问题是一个经典的NP完全问题,多人旅行商问题的求解则更具挑战性.以往对求解多人旅行商问题的研究局限于以所有成员路径总和最小为优化标准,而对以所有成员路径最大值最小为优化标准的另一类多人旅行商问题却未加注意.文章给出了这两类多人旅行商问题的形式化描述,探讨了利用遗传算法求解这两类多人旅行商问题的基本思想和具体方案,进行了仿真实验验证.仿真实验数据表明,这是一种高效而且适应性强的多入旅行商问题求解方法.
TSP问题总结归纳
热门推荐
syddf
10-26 7万+
TSP问题即旅行商问题，经典的TSP可以描述为：一个商品推销员要去若干个城市推销商品，该推销员从一个城市出发，需要经过所有城市后，回到出发地。应如何选择行进路线，以使总的行程最短。从图论的角度来看，该问题实质是在一个带权完全无向图中，找一个权值最小的哈密尔顿回路。 旅行商问题有很多种不同的问法，最近做了几个关于TSP的题，下面总结一下。由于大部分TSP问题都是NP-Hard的，因此很难得到什么高效...
TSP的求解
weixin_40493805的博客
04-17 2892
1、TSP这类问题可以总结一下，类似的排序问题也可以用这种方法解决。 2、TSP主要是指38（随便说的可以是n）个城市之间的访问顺序，然后形成的距离最小。 3、主要的问题是怎么生成 这个序列，然后迭代计算得到最优的序列。 生成序列，应该比较好办，大部分的软件都有函数，可以生成，比如matlab可以用 randperm ，不重复的数字。 4、然后是，怎么变换这个序列，得到新的一个序列，就是解。一种简单的方法，就是随机生成2个数字，比如12和34，然后让12位置和34位置 对应的数字进行对调。 分析：模拟退火算
旅行商TSP问题
FlyingJack
05-18 357
旅行商问题（TSP问题）：每个点经过有且仅有一次的最短回路 解法：动态规划 HDU5067：经典TSP问题 #include <bits/stdc++.h> using namespace std; int const inf = 0x3f3f3f3f; typedef pair<int,int>pii; int const N = 12; int n,m,mp[N][N],dp[1<<N][N],cnt; pii a[N]; int TSP(){ /
图论-商旅旅行变形问题
wust_cyl的博客
05-14 2090
看如下问题：给定一幅n个点m条边的图和S个一定要经过的点，问从0号点出发，经过这S个点再回到0号点的最短路径长度是多少。(S&lt;=10)这个问题初看起来，很难解决，但是它其实是商旅旅行问题的变形。一定要经过s个点，那我们就只经过这s个点。我们先通过dijstra跑出这S点与其他点的最短路，然后就是已知这s个点的之间的j距离，然后求从0点遍历所有点然后回到的0点的问题了。商旅旅行问题。输入描述:...
Java遗传算法求解TSP
最新发布
08-31
您好！可以使用遗传算法来解决旅行商问题（TSP）。遗传算法是一种基于生物进化原理的优化算法，适用于求解各类优化问题，包括TSP。 下面是使用Java实现遗传算法求解TSP的一般步骤： 1. 定义基因表示：将每个城市视为一个基因，可以使用整数数组或二进制串表示一条路径。 2. 初始化种群：随机生成一定数量的个体（路径），构成初始种群。 3. 适应度函数：定义评价函数，计算每个个体的适应度。在TSP中，可以将路径长度作为适应度。 4. 选择操作：根据适应度选择一定数量的父代个体，可以使用轮盘赌选择、锦标赛选择等方法。 5. 交叉操作：对选出的父代个体进行交叉（基因重组），生成新的子代个体。 6. 变异操作：对子代个体进行变异，引入随机扰动，增加搜索的多样性。 7. 更新种群：根据选择、交叉和变异操作得到的子代个体，更新当前种群。 8. 终止条件：达到预定的终止条件（例如最大迭代次数、达到最优解等）时停止算法。 9. 输出结果：输出最优解（最短路径）及其路径长度。 10. 可选优化：可以采取一些改进措施，如精英保留、种群大小调整、参数调优等。 您可以根据以上步骤，编写Java代码来实现遗传算法求解TSP问题。希望对您有所帮助！如果您有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值