数学建模常用算法:模拟退火算法求解tsp问题+att48算例测试【java实现--详细注释】

简介: 数学建模常用算法:模拟退火算法求解tsp问题+att48算例测试【java实现--详细注释】

代码

package com.dam.heuristic.sa.test;
import java.util.Arrays;
import java.util.Random;
/**
 * 模拟退火
 */
public class SaApi {
    //序列长度
    private int sequenceLen;
    //初始温度
    private double startT;
    //结束温度
    private double endT;
    //每个温度的迭代次数
    private int timeInPerTemperature;
    //公式中的常数k
    private double k;
    //降温系数
    private double coolingCoefficient;
    //距离矩阵
    private double[][] distanceMatrix;
    /**
     * 构造函数,用于创建对象
     */
    public SaApi(double startT, double endT, int timeInPerTemperature, double k, double coolingCoefficient, double[][] distanceMatrix) {
        this.sequenceLen = distanceMatrix[0].length;
        this.startT = startT;
        this.endT = endT;
        this.timeInPerTemperature = timeInPerTemperature;
        this.k = k;
        this.coolingCoefficient = coolingCoefficient;
        this.distanceMatrix = distanceMatrix;
    }
    /**
     * 模拟退火算法接口
     */
    public void solve() {
        定义变量
        long startTime = System.currentTimeMillis();
        //当前温度
        double curT = this.startT;
        ///最优解
        //最优温度
        double bestT = this.startT;
        //序列
        int[] localSequence = new int[this.sequenceLen];
        //最优序列
        int[] bestSequence;
        //存储求得最优解的时间
        long bestTime = 0;
        //最优序列对应的目标函数值
        double bestObjectValue = 0;
        //上一序列的目标函数值
        double lastObjectValue = Double.MAX_VALUE;
        ///对象
        Random random = new Random();
        生成初始序列
        this.generateInitialSequence(localSequence);
        //初始化bestSequence,刚开始的最优序列为初始序列
        bestSequence = localSequence.clone();
        bestObjectValue = this.getObjectValue(bestSequence);
//        System.out.println("初始序列:" + Arrays.toString(bestSequence));
//        System.out.println("初始目标函数值:" + bestObjectValue);
        对序列进行迭代优化
        while (curT > this.endT) {
//            System.out.println("当前温度:" + curT + ",--------------------------------------------------------------");
            for (int i = 0; i < this.timeInPerTemperature; i++) {
                int[] tempSequence = this.generateNewSequence(localSequence);
                double tempObjectValue = this.getObjectValue(tempSequence);
                double de = tempObjectValue - lastObjectValue;
//                System.out.println("温度:" + bestT);
                if (de < 0) {
                    localSequence = tempSequence.clone();
                    lastObjectValue = tempObjectValue;
                    if (tempObjectValue<bestObjectValue){
                        //更新最优解
                        bestT = curT;
                        bestObjectValue = tempObjectValue;
                        bestSequence = tempSequence.clone();
//                    bestTime = (System.currentTimeMillis() - startTime);
//                        System.out.println("找到更优解:" + bestObjectValue + ",计算时间:" + bestTime + "ms");
                    }
                } else {
                    double p = Math.exp(-de / (this.k * curT));
                    if (p > random.nextDouble()) {
//                        System.out.println("当前接受差解为:" + tempObjectValue);
                        //替换序列
                        localSequence = tempSequence.clone();
                        lastObjectValue = tempObjectValue;
                    } else {
//                        System.out.println("不接受");
                    }
                }
            }
            curT *= this.coolingCoefficient;
        }
        System.out.println("-----------------------------------------------------------------------------------------------------------------------------------");
        System.out.println("最佳温度:" + bestT);
        System.out.println("最优目标函数值:" + bestObjectValue);
        System.out.println("最优解对应序列:" + Arrays.toString(bestSequence));
        System.out.println("求解时间:" + (System.currentTimeMillis() - startTime) + "ms");
    }
    /**
     * 生成初始序列
     */
    public void generateInitialSequence(int[] sequence) {
//        HashSet<Integer> sequenceSet = new HashSet<>();
//        for (int i = 1; i < sequence.length; i++) {
//            sequenceSet.add(i);
//        }
//
//        //贪婪算法获取初始序列,从城市0开始旅行,即城市0为起点城市
//        sequence[0] = 0;
//        //每次获取离当前城市最近的城市,并加入到sequence
//        for (int i = 1; i < sequence.length; i++) {
//            //寻找离i-1城市最近的城市,即确定第i个城市是哪个
//            double smallDistance = Double.MAX_VALUE;
//            int curCity = 0;
//            for (Integer j : sequenceSet) {
//                if (this.distanceMatrix[sequence[i - 1]][j] < smallDistance && j != sequence[i - 1]) {
//                    smallDistance = this.distanceMatrix[sequence[i - 1]][j];
//                    curCity = j;
//                }
//            }
//            sequence[i] = curCity;
//            sequenceSet.remove(curCity);
//        }
        for (int i = 0; i < sequence.length; i++) {
            sequence[i] = i;
        }
    }
    /**
     * 根据当前序列获取目标函数值
     *
     * @param sequence
     * @return
     */
    public double getObjectValue(int[] sequence) {
        double objectValue = 0;
        //计算从第0个城市到最后一个城市的路程
        for (int i = 0; i < sequence.length - 1; i++) {
            objectValue += this.distanceMatrix[sequence[i]][sequence[i + 1]];
        }
        //计算最后一个城市到第0个城市的路程
        objectValue += this.distanceMatrix[sequence[0]][sequence[sequence.length - 1]];
        return objectValue;
    }
    /**
     * 生产新序列
     *
     * @param sequence
     * @return
     */
    public int[] generateNewSequence(int[] sequence) {
        int[] sequenceClone = sequence.clone();
        //对序列中的元素进行打乱,即可产生新的序列
        Random random = new Random();
        int i = random.nextInt(sequence.length);
        int j = random.nextInt(sequence.length);
        while (i == j) {
            j = random.nextInt(sequence.length);
        }
        int temp = sequenceClone[i];
        sequenceClone[i] = sequenceClone[j];
        sequenceClone[j] = temp;
        return sequenceClone;
    }
}

模拟退火过程


测试

package com.dam.heuristic.sa.test;
import com.dam.heuristic.sa.improve.ImproveSaApi;
import java.io.File;
import java.io.FileInputStream;
public class SAMainRun {
    public static void main(String[] args) throws Exception {
        声明变量
        //距离矩阵,可以直接获取任意两个编号城市的距离
        double[][] distanceMatrix;
        读取数据
        String data = read(new File("src/main/java/com/data/tsp/att48.txt"), "GBK");
        String[] cityDataArr = data.split("\n");
        //初始化数组
        distanceMatrix = new double[cityDataArr.length][cityDataArr.length];
        for (int i = 0; i < cityDataArr.length; i++) {
            String[] city1Arr = cityDataArr[i].split(" ");
            int cityOne = Integer.valueOf(city1Arr[0]);
            for (int j = 0; j < i; j++) {
                String[] city2Arr = cityDataArr[j].split(" ");
                int cityTwo = Integer.valueOf(city2Arr[0]);
                if (cityOne == cityTwo) {
                    distanceMatrix[cityOne - 1][cityTwo - 1] = 0;
                } else {
                    distanceMatrix[cityOne - 1][cityTwo - 1] = getDistance(Double.valueOf(city1Arr[1]), Double.valueOf(city1Arr[2]), Double.valueOf(city2Arr[1]), Double.valueOf(city2Arr[2]));
                    //对称赋值
                    distanceMatrix[cityTwo - 1][cityOne - 1] = distanceMatrix[cityOne - 1][cityTwo - 1];
                }
            }
        }
     /*   System.out.println("输出距离矩阵-------------------------------------------------------------------");
        for (double[] matrix : distanceMatrix) {
            System.out.println(Arrays.toString(matrix));
        }*/
        System.out.println("saApi求解----------------------------------------------------------------------------");
        SaApi saApi = new SaApi(100000, 1e-8, 3000, 10000.0, 0.98, distanceMatrix);
        saApi.solve();
    }
    /**
     * 给定两个城市坐标,获取两个城市的直线距离
     *
     * @param x1
     * @param y1
     * @param x2
     * @param y2
     * @return
     */
    private static double getDistance(double x1, double y1, double x2, double y2) {
        return Math.sqrt((Math.pow((x1 - x2), 2) + Math.pow((y1 - y2), 2)) / 10);
    }
    private static String read(File f, String charset) throws Exception {
        FileInputStream fstream = new FileInputStream(f);
        try {
            int fileSize = (int) f.length();
            if (fileSize > 1024 * 512) {
                throw new Exception("File too large to read! size=" + fileSize);
            }
            byte[] buffer = new byte[fileSize];
            fstream.read(buffer);
            return new String(buffer, charset);
        } finally {
            try {
                fstream.close();
            } catch (Exception e) {
            }
        }
    }
}


saApi求解----------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------------
最佳温度:0.003086887433472753
最优目标函数值:11085.716110897114
最优解对应序列:[3, 25, 41, 1, 28, 4, 47, 33, 40, 15, 21, 39, 45, 35, 29, 42, 16, 26, 18, 36, 5, 27, 6, 17, 43, 30, 37, 8, 7, 0, 2, 22, 10, 11, 14, 32, 19, 46, 20, 12, 13, 24, 38, 31, 23, 9, 44, 34]
求解时间:1944ms
Process finished with exit code 0
目录
相关文章
|
6天前
|
监控 算法 网络协议
Java 实现局域网电脑屏幕监控算法揭秘
在数字化办公环境中,局域网电脑屏幕监控至关重要。本文介绍用Java实现这一功能的算法,涵盖图像采集、数据传输和监控端显示三个关键环节。通过Java的AWT/Swing库和Robot类抓取屏幕图像,使用Socket进行TCP/IP通信传输图像数据,并利用ImageIO类在监控端展示图像。整个过程确保高效、实时和准确,为提升数字化管理提供了技术基础。
40 15
|
3月前
|
存储 人工智能 算法
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
这篇文章详细介绍了Dijkstra和Floyd算法,这两种算法分别用于解决单源和多源最短路径问题,并且提供了Java语言的实现代码。
101 3
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
|
2天前
|
机器学习/深度学习 算法 PyTorch
深度强化学习中SAC算法:数学原理、网络架构及其PyTorch实现
软演员-评论家算法(Soft Actor-Critic, SAC)是深度强化学习领域的重要进展,基于最大熵框架优化策略,在探索与利用之间实现动态平衡。SAC通过双Q网络设计和自适应温度参数,提升了训练稳定性和样本效率。本文详细解析了SAC的数学原理、网络架构及PyTorch实现,涵盖演员网络的动作采样与对数概率计算、评论家网络的Q值估计及其损失函数,并介绍了完整的SAC智能体实现流程。SAC在连续动作空间中表现出色,具有高样本效率和稳定的训练过程,适合实际应用场景。
20 7
深度强化学习中SAC算法:数学原理、网络架构及其PyTorch实现
|
12天前
|
缓存 算法 搜索推荐
Java中的算法优化与复杂度分析
在Java开发中,理解和优化算法的时间复杂度和空间复杂度是提升程序性能的关键。通过合理选择数据结构、避免重复计算、应用分治法等策略,可以显著提高算法效率。在实际开发中,应该根据具体需求和场景,选择合适的优化方法,从而编写出高效、可靠的代码。
25 6
|
1月前
|
Java
Java 中的注释
1. 单行注释:// 2. 多行注释:/* */ 3. 文档注释::/** **/
|
2月前
|
Java 测试技术 Maven
Java一分钟之-PowerMock:静态方法与私有方法测试
通过本文的详细介绍,您可以使用PowerMock轻松地测试Java代码中的静态方法和私有方法。PowerMock通过扩展Mockito,提供了强大的功能,帮助开发者在复杂的测试场景中保持高效和准确的单元测试。希望本文对您的Java单元测试有所帮助。
295 2
|
3月前
|
Java 程序员 测试技术
Java|让 JUnit4 测试类自动注入 logger 和被测 Service
本文介绍如何通过自定义 IDEA 的 JUnit4 Test Class 模板,实现生成测试类时自动注入 logger 和被测 Service。
41 5
|
3月前
|
Java 测试技术 程序员
💡Java 零基础 | 深入理解注释的重要性与应用
【10月更文挑战第10天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
39 5
|
3月前
|
存储 人工智能 Java
将 Spring AI 与 LLM 结合使用以生成 Java 测试
AIDocumentLibraryChat 项目通过 GitHub URL 为指定的 Java 类生成测试代码,支持 granite-code 和 deepseek-coder-v2 模型。项目包括控制器、服务和配置,能处理源代码解析、依赖加载及测试代码生成,旨在评估 LLM 对开发测试的支持能力。
65 1
|
3月前
|
算法 搜索推荐 Java
java 后端 使用 Graphics2D 制作海报,画echarts图,带工具类,各种细节:如头像切割成圆形,文字换行算法(完美实验success),解决画上文字、图片后不清晰问题
这篇文章介绍了如何使用Java后端技术,结合Graphics2D和Echarts等工具,生成包含个性化信息和图表的海报,并提供了详细的代码实现和GitHub项目链接。
161 0
java 后端 使用 Graphics2D 制作海报,画echarts图,带工具类,各种细节:如头像切割成圆形,文字换行算法(完美实验success),解决画上文字、图片后不清晰问题