数学建模常用算法:模拟退火算法求解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
目录
相关文章
|
4月前
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
本文聚焦 MySQL 集群架构中的负载均衡算法,阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法,分析各自优缺点及适用场景。并提供 Java 语言代码实现示例,助力直观理解。文章结构清晰,语言通俗易懂,对理解和应用负载均衡算法具有实用价值和参考价值。
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
|
13天前
|
机器学习/深度学习 人工智能 算法
当AI提示词遇见精密算法:TimeGuessr如何用数学魔法打造文化游戏新体验
TimeGuessr融合AI与历史文化,首创时间与空间双维度评分体系,结合分段惩罚、Haversine距离计算与加权算法,辅以连击、速度与完美奖励机制,实现公平且富挑战性的游戏体验。
|
4月前
|
存储 缓存 监控
上网行为监控系统剖析:基于 Java LinkedHashMap 算法的时间序列追踪机制探究
数字化办公蓬勃发展的背景下,上网行为监控系统已成为企业维护信息安全、提升工作效能的关键手段。该系统需实时记录并深入分析员工的网络访问行为,如何高效存储和管理这些处于动态变化中的数据,便成为亟待解决的核心问题。Java 语言中的LinkedHashMap数据结构,凭借其独有的有序性特征以及可灵活配置的淘汰策略,为上网行为监控系统提供了一种兼顾性能与功能需求的数据管理方案。本文将对LinkedHashMap在上网行为监控系统中的应用原理、实现路径及其应用价值展开深入探究。
104 3
|
13天前
|
存储 算法 数据可视化
基于禁忌搜索算法的TSP问题最优路径搜索matlab仿真
本程序基于禁忌搜索算法解决旅行商问题(TSP),旨在寻找访问多个城市的最短路径。使用 MATLAB 2022A 编写,包含城市坐标生成、路径优化及结果可视化功能。通过禁忌列表、禁忌长度与藐视准则等机制,提升搜索效率与解的质量,适用于物流配送、路径规划等场景。
|
4月前
|
人工智能 算法 NoSQL
LRU算法的Java实现
LRU(Least Recently Used)算法用于淘汰最近最少使用的数据,常应用于内存管理策略中。在Redis中,通过`maxmemory-policy`配置实现不同淘汰策略,如`allkeys-lru`和`volatile-lru`等,采用采样方式近似LRU以优化性能。Java中可通过`LinkedHashMap`轻松实现LRUCache,利用其`accessOrder`特性和`removeEldestEntry`方法完成缓存淘汰逻辑,代码简洁高效。
193 0
|
3月前
|
存储 算法 安全
Java中的对称加密算法的原理与实现
本文详细解析了Java中三种常用对称加密算法(AES、DES、3DES)的实现原理及应用。对称加密使用相同密钥进行加解密,适合数据安全传输与存储。AES作为现代标准,支持128/192/256位密钥,安全性高;DES采用56位密钥,现已不够安全;3DES通过三重加密增强安全性,但性能较低。文章提供了各算法的具体Java代码示例,便于快速上手实现加密解密操作,帮助用户根据需求选择合适的加密方案保护数据安全。
341 58
|
2月前
|
存储 负载均衡 算法
我们来说一说 Java 的一致性 Hash 算法
我是小假 期待与你的下一次相遇 ~
102 1
|
4月前
|
人工智能 自然语言处理 测试技术
UGMathBench:评估语言模型数学推理能力的动态基准测试数据集
近年来,人工智能蓬勃发展,自然语言模型(LLM)进展显著。语言模型被广泛应用于自动翻译、智能客服、甚至医疗、金融、天气等领域。而研究者们仍在不断努力,致力于提高语言模型的规模和性能。随着语言模型的蓬勃发展,评估一个语言模型的性能变得越来越重要。其中一个重要的评估指标,就是衡量语言模型的推理能力和解决数学问题的能力。
272 38
|
2月前
|
存储 监控 算法
企业上网监控场景下布隆过滤器的 Java 算法构建及其性能优化研究
布隆过滤器是一种高效的数据结构,广泛应用于企业上网监控系统中,用于快速判断员工访问的网址是否为违规站点。相比传统哈希表,它具有更低的内存占用和更快的查询速度,支持实时拦截、动态更新和资源压缩,有效提升系统性能并降低成本。
72 0
|
4月前
|
监控 算法 JavaScript
公司局域网管理视域下 Node.js 图算法的深度应用研究:拓扑结构建模与流量优化策略探析
本文探讨了图论算法在公司局域网管理中的应用,针对设备互联复杂、流量调度低效及安全监控困难等问题,提出基于图论的解决方案。通过节点与边建模局域网拓扑结构,利用DFS/BFS实现设备快速发现,Dijkstra算法优化流量路径,社区检测算法识别安全风险。结合WorkWin软件实例,展示了算法在设备管理、流量调度与安全监控中的价值,为智能化局域网管理提供了理论与实践指导。
128 3

热门文章

最新文章