0096 克鲁斯卡尔算法，迪杰斯特拉算法

news2025/1/17 15:55:13

 

 

 

 

 

 

 

/*
 * 克鲁斯卡尔算法
 * 1.用来求加权连通图的最小生成树的算法
 * 2.思想：按照权值从小到大的顺序，选择n-1条边，并保证这n-1条边不构成回路
 * 3.先构造一个只含n个顶点的森林，依权值从小到大从连通网中选择边加入到森林中
 *   并使森林不产生回路，直至森林变成一棵树
 * 
 * 终点：将所有顶点从小到大排序后，某个顶点的终点就是与它连通的最大顶点
 * 判断回路：加入边的两个顶点不能都指向同一个终点，否则构成回路
 * 
 * 应用——修路问题
 * 
 */
public class Kruskal {
    private int edgeNum;//边的个数
    private char[] vertexs;//顶点数组
    private int[][] matrix;//邻接矩阵
    private static final int INF = Integer.MAX_VALUE;//使用INF表示两个顶点不连通
    
    
    public static void main(String[] args) {
        char[] vertexs = {'A','B','C','D','E','F','G'};
        //邻接矩阵
        int[][] matrix = {
                {0  ,12 ,INF,INF,INF,16 ,14 },
                {12 ,0  ,10 ,INF,INF,7  ,INF},
                {INF,10 ,0  ,3  ,5  ,6  ,INF},
                {INF,INF,3  ,0  ,4  ,INF,INF},
                {INF,INF,5  ,4  ,0  ,2  ,8  },
                {16 ,7  ,6  ,INF,2  ,0  ,9  },
                {14 ,INF,INF,INF,8  ,9  ,0  }};
        
        //创建对象实例
        Kruskal kruskal = new Kruskal(vertexs, matrix);
        //输出
        kruskal.print();
        kruskal.kruskal();
        
    }
    
    //构造器
    public Kruskal(char[] vertexs,int[][] matrix) {
        //初始化顶点数和边数
        int vlen = vertexs.length;
        
        //初始化顶点(复制拷贝)
        this.vertexs = new char[vlen];
        for(int i = 0;i < vertexs.length;i++) {
            this.vertexs[i] = vertexs[i];
        }
        //this.vertexs = vertexs;
        
        //初始化边(复制拷贝)
        this.matrix = new int[vlen][vlen];
        for(int i = 0;i < vlen;i++) {
            for(int j = 0;j < vlen;j++) {
                this.matrix[i][j] = matrix[i][j];
            }
        }
        
        //统计边
        for(int i = 0;i < vlen;i++) {
            for(int j = i+1;j < vlen;j++) {
                if (this.matrix[i][j] != INF) {
                    edgeNum++;
                }
            }
        }
    }
    
    //克鲁斯卡尔算法
    public void kruskal() {
        int index = 0;//表示最后结果数组的索引
        int[] ends = new int[edgeNum];//保存已有最小生成树中每个顶点的终点
        
        //创建结果数组，保存最小生成树
        EData[] res = new EData[edgeNum];
        
        //获取图中所有边的集合
        EData[] edges = getEdges();
        
        //按照边权值进行排序
        sortEdges(edges);
        
        //遍历edges数组，将边添加到最小生成树，判断是否构成回路,如不构成加入到res
        for(int i = 0;i < edgeNum;i++) {
            //获取第i条边的一个点
            int p1 = getPosition(edges[i].start);
            //获取第i条边的另一个点
            int p2 = getPosition(edges[i].end);
            
            //获取p1,p2在已有最小生成树的终点
            int m = getEnd(ends, p1);
            int n = getEnd(ends, p2);
            
            //判断是否构成回路
            if (m != n) {//没构成
                ends[m] = n;//设置m在已有最小生成树的终点
                res[index++] = edges[i];//加入到res
            }
        }
        
        //统计并输出最小生成树
        System.out.println("最小生成树为");
        for(int i = 0;i < index;i++) {
            System.out.println(res[i]);
        }
    }
    
    //输出邻接矩阵
    public void print() {
        System.out.println("邻接矩阵为");
        for(int i = 0;i < vertexs.length;i++) {
            for(int j = 0;j < vertexs.length;j++) {
                System.out.printf("%8d\t",matrix[i][j]);
            }
            System.out.println();
        }
    }
    
    //对边权值进行排序(冒泡)
    //edges:边的集合
    private void sortEdges(EData[] edges) {
        for(int i = 0;i < edges.length - 1;i++) {
            for(int j = 0;j < edges.length - 1 - i;j++) {
                if (edges[j].weight > edges[j+1].weight) {
                    EData temp = edges[j];
                    edges[j] = edges[j+1];
                    edges[j+1] = temp;
                }
            }
        }
    }
    
    //ch:顶点值，返回顶点对应下标,找不到返回-1
    private int getPosition(char ch) {
        for(int i = 0;i < vertexs.length;i++) {
            if (vertexs[i] == ch) {//找到
                return i;
            }
        }
        return -1;
    }
    
    //获取图中的边(通过邻接矩阵)，放入EData[]数组，遍历该数组
    private EData[] getEdges() {
        int index = 0;
        EData[] edges = new EData[edgeNum];
        for(int i = 0;i < vertexs.length;i++) {
            for(int j = i+1;j < vertexs.length;j++) {
                if (matrix[i][j] != INF) {
                    edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }
    
    //获取下标为i的顶点的终点
    //ends:顶点终点的集合，i：顶点对应下标
    private int getEnd(int[] ends,int i) {
        while(ends[i] != 0) {
            i = ends[i];
        }
        return i;
    }
}


//创建类EData,对象实例表示一条边
class EData{
    char start;//边的一个点
    char end;//边的另一个点
    int weight;//边的权值
    
    //构造器
    public EData(char start,char end,int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
    }

    //重新toString,输出边信息
    @Override
    public String toString() {
        return "EData [<" + start + ", " + end + ">=" + weight + "]";
    }
    
}

import java.util.Arrays;
/*
 * 迪杰斯特拉算法
 * 1.迪杰斯特拉算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径
 * 2.主要特点是以起始点为中心向外层层扩展（广度优先搜索思想），直到扩展到终点为止
 * 
 * 算法过程
 * 设置出发顶点v，顶点集合V{v1,v2,...}，v到V中各顶点的距离构成距离集合Dis，
 * Dis{d1,d2...}，Dis集合记录v到各顶点的距离（到自身可看成0，v到vi距离对应为di）
 * 
 * 1.从Dis中选择最小的di并移出Dis集合，同时移出V集合中对应的顶点vi，此时v到vi即为最短路径
 * 2.更新Dis集合：比较v到V集合中顶点的距离值，与v通过vi到V集合中顶点的距离值，保留值较小的一个
 *      （同时更新顶点前驱为vi，表明是通过vi到达的）
 * 3.重复执行1，2，直到最短路径顶点为目标顶点时结束
 * 
 * 
 * 
 * 应用——最短路径问题
 * 
 */
public class Dijkstra {
    public static void main(String[] args) {
        char[] vertex = {'A','B','C','D','E','F','G'};
        //邻接矩阵
        int[][] matrix = new int[vertex.length][vertex.length];
        final int N = 65535;//表示不可连接
        matrix[0] = new int[] {N,5,7,N,N,N,2};
        matrix[1] = new int[] {5,N,N,9,N,N,3};
        matrix[2] = new int[] {7,N,N,N,8,N,N};
        matrix[3] = new int[] {N,9,N,N,N,4,N};
        matrix[4] = new int[] {N,N,8,N,N,5,4};
        matrix[5] = new int[] {N,N,N,4,5,N,6};
        matrix[6] = new int[] {2,3,N,N,4,6,N};
        
        //创建Graph对象
        Graph graph = new Graph(vertex, matrix);
        //输出邻接矩阵
        graph.showGraph();
        //测试迪杰斯特拉算法
        graph.dsj(6);
        graph.showDijkstra();
    }
}

class Graph{
    private char[] vertex;//顶点数组
    private int[][] matrix;//邻接矩阵
    private VisitedVertex visitedVertex;//已访问顶点集合
    
    //构造器
    public Graph(char[] vertex,int[][] matrix) {
        this.vertex = vertex;
        this.matrix = matrix;
    }
    
    //显示结果
    public void showDijkstra() {
        visitedVertex.show();
    }
    
    //显示图
    public void showGraph() {
        for(int[] link : matrix) {
            System.out.println(Arrays.toString(link));
        }
    }
    
    //迪杰斯特拉算法
    //index:出发顶点对应的下标
    public void dsj(int index) {
        visitedVertex = new VisitedVertex(vertex.length, index);
        update(index);//更新index顶点到周围顶点的距离和前驱顶点
        
        for(int j = 1;j < vertex.length;j++) {
            index = visitedVertex.updateArr();//选择并返回新的访问结点
            update(index);//更新index顶点到周围顶点的距离和前驱顶点
        }
    }
    
    //更新index下标顶点到各个顶点的距离和前驱顶点
    private void update(int index) {
        int len = 0;
        //遍历邻接矩阵index行
        for(int j = 0;j < matrix[index].length;j++) {
            //len:出发顶点到index顶点的距离 + 从index顶点到j顶点的距离 
            len = visitedVertex.getDis(index) + matrix[index][j];
            //如果顶点j没有被访问且len小于出发顶点到j顶点的距离，就更新
            if (!visitedVertex.in(j) && len < visitedVertex.getDis(j)) {
                visitedVertex.updatePre(j, index);//更新j顶点的前驱为index顶点
                visitedVertex.updateDis(j, len);//更新出发顶点到j顶点的距离
            }
        }
    }
}

//已访问顶点集合
class VisitedVertex{
    //记录各个顶点是否访问过（1表示访问，0表示未访问）
    public int[] already_arr;
    //每个下标对应的值为前一个顶点下标
    public int[] pre_visited;
    //记录出发顶点到其他所有顶点的距离
    public int[] dis;
    
    //构造器
    //lenght:顶点个数，index：出发顶点对应的下标
    public VisitedVertex(int lenght,int index) {
        this.already_arr = new int[lenght];
        this.pre_visited = new int[lenght];
        this.dis = new int[lenght];
        
        //初始化dis，设置出发顶点到自身的距离为0，其他为65535
        Arrays.fill(dis, 65535);
        this.dis[index] = 0;
        this.already_arr[index] = 1;//设置出发顶点被访问过
    }
    
    //判断index是否被访问过，如果访问过返回true
    public boolean in(int index) {
        return already_arr[index] == 1;
    }
    
    //更新出发顶点到index顶点的距离
    public void updateDis(int index,int len) {
        dis[index] = len;
    }
    
    //更新顶点前驱为index结点
    public void updatePre(int pre,int index) {
        pre_visited[pre] = index;
    }
    
    //返回出发顶点到index顶点的距离
    public int getDis(int index) {
        return dis[index];
    }
    
    //继续选择并返回新的访问顶点
    public int updateArr() {
        int min = 65535;
        int index = 0;
        for(int i = 0;i < already_arr.length;i++) {
            if (already_arr[i] == 0 && dis[i] < min) {
                min = dis[i];
                index = i;
            }
        }
        //更新index顶点被访问过
        already_arr[index] = 1;
        return index;
    }
    
    //显示最后结果
    public void show() {
        System.out.println("==============================");
        //输出already_arr
        for(int i : already_arr) {
            System.out.print(i + " ");
        }
        System.out.println();
        
        //输出pre_visited
        for(int i : pre_visited) {
            System.out.print(i + " ");
        }
        System.out.println();
        
        //输出dis
        for(int i : dis) {
            System.out.print(i + " ");
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/9964.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

web自动化测试-webdriver实现

web自动化测试-webdriver实现

webdriver实现基本语法1.Select下拉列表1.1下拉列表单选1.2下拉列表多选2.非Select下拉列表3.文件上传1.1input单个文件上传1.2input多个文件上传1.3非input文件上传1.Select下拉列表 1.1下拉列表单选 from selenium import webdriver from selenium.webdriver.support.ui imp…
阅读更多...
GPU驱动及CUDA安装流程介绍

GPU驱动及CUDA安装流程介绍

安装前准备工作 确认GPU型号和操作系统版本   准备gpu驱动和CUDA软件包   在nvidia官网进行驱动包下载   GPU驱动下载链接    Linux系统均选择 Linux 64-bit、CUDA Toolkit选择最新版本   注意该版本一定要大于等于cuda软件的版本。   选择CUDA及GPU驱动版本&#…
阅读更多...
m基于matlab的TDSCDMA系统性能仿真

m基于matlab的TDSCDMA系统性能仿真

目录 1.算法概述 2.仿真效果预览 3.核心MATLAB代码预览 4.完整MATLAB程序 1.算法概述 TD-SCDMA的中文含义为时分复用同步码分多址接入&#xff0c;是由中国第一次提出、在无线传输技术(RTT)的基础上完成并已正式成为被ITU接纳的国际移动通信标准。这是中国移动通信界的一次…
阅读更多...
解读ESSumm: Extractive Speech Summarization from Untranscribed Meeting

解读ESSumm: Extractive Speech Summarization from Untranscribed Meeting

ESSumm: Extractive Speech Summarization from Untranscribed Meeting 从非转录会议中提取语音摘要&#xff08;非转录&#xff1a;原音频&#xff0c;没有转化为文本或者其他格式&#xff09; 论文地址 https://arxiv.org/abs/2209.06913 摘要 在本文中&#xff0c;我们为…
阅读更多...
JS中的迭代器、可迭代对象、生成器

JS中的迭代器、可迭代对象、生成器

迭代器 迭代器&#xff08;iterator&#xff09;&#xff0c;是使用户在容器对象&#xff08;container&#xff0c;例如链表或数组&#xff09;上可以遍历访问的对象&#xff0c;使用该接口无需关心容器对象的内部实现细节。 从上面定义上来看&#xff0c;迭代器是帮助我们对…
阅读更多...
SpringMVC 源码学习 返回值处理

SpringMVC 源码学习 返回值处理

SpringMVC中对返回值的数据基本分为两类&#xff1a; 1、响应数据 2、响应页面 一、响应数据 响应数据大多数都是将返回值的格式转换为JSON格式然后展示在页面或者保存i起来。 第一步&#xff1a;在SpringBoot中需要引入json场景 <dependency><groupId>org.sprin…
阅读更多...
如何设计存储架构

如何设计存储架构

步骤 步骤1&#xff1a;估算性能需求 任务 基于具体的业务场景来估算性能需求&#xff0c;包括存储量、读写性能等 挑战 不知道如何估算担心估算不准 步骤2&#xff1a;选择存储系统 任务 根据技术储备、方案优缺点选择合适的存储系统 挑战 不知道有哪些存储系统知道…
阅读更多...
UG NX二次开发（C#）-UI Styler-批量选择点

UG NX二次开发（C#）-UI Styler-批量选择点

1、前言 在设计UG NX的对话框界面时，有时需要选择点，在UI Styler编辑器中已经设置好了可以指定点选择按钮，这个点选择对话框是单选，不是多选的，如果想选择多个点，那么可以采用对象选择按钮，本文介绍下选择点的操作。 2、指定点按钮 2.1 设计UI Styler UG NX的UI Sty…
阅读更多...
vscode中Emmet语法的使用

vscode中Emmet语法的使用

每篇博文的浪漫主义 【镰仓旅拍|落日绝景 极致画质|沉浸式旅行 FX3】 https://www.bilibili.com/video/BV1jg411Y7vC/?share_sourcecopy_web&vd_source385ba0043075be7c24c4aeb4aaa73352 镰仓旅拍|落日绝景 极致画质|沉浸式旅行 FX31.1快速生成HTML结构语法 生成标签直接…
阅读更多...
想要彻底卸载Mac应用程序，还得要用这些方法才行

想要彻底卸载Mac应用程序，还得要用这些方法才行

Mac电脑如果有太多无用的应用程序&#xff0c;很有可能会拖垮Mac系统的运行速度。因此&#xff0c;卸载电脑中无用的软件是优化Mac系统运行速度的最佳方式之一。Mac删除应用程序特别简单&#xff0c;长点击应用点击x&#xff0c;或是直接将应用拖进废纸篓。但是有一些应用长按没…
阅读更多...
Qt——（详细）“项目在Debug构建环境下能运行而在Release构建环境下不能运行”解决方案之一，以及 禁用（黄色）警告

Qt——（详细）“项目在Debug构建环境下能运行而在Release构建环境下不能运行”解决方案之一，以及 禁用（黄色）警告

系列文章目录 提示&#xff1a; 文章目录系列文章目录前言环境一、问题准备工作——为了在Release环境下可以进行断点调试分析二、解决1、根据需求&#xff0c;对函数类型进行更改2、根据需求&#xff0c;在函数内添加“return [int]”延伸——“禁用警告”消除 变量 的“黄色感…
阅读更多...
现代修谱，如何看待支系单飞的现象？

现代修谱，如何看待支系单飞的现象？

族谱与支谱、房谱的区别 现代修谱&#xff0c;修的是什么谱&#xff0c;你知道吗&#xff1f;其实现代修谱的种类有很多种&#xff0c;有支谱、房谱、族谱、宗谱、统谱、通谱等等&#xff0c;而这些在生活中都被我们简称为家谱。 不过在现代修谱里&#xff0c;宗谱、统谱、通谱…
阅读更多...
极智编程 | 谈谈 C++ 中容器 map 和 unordered_map 的区别

极智编程 | 谈谈 C++ 中容器 map 和 unordered_map 的区别

欢迎关注我的公众号 [极智视界]&#xff0c;获取我的更多笔记分享 大家好&#xff0c;我是极智视界&#xff0c;本文来 谈谈 C 中 map 和 unordered_map 的区别。 map 和 unordered_map 都可以看做是一种 key-value 的映射关系&#xff0c;unordered_map 可以理解为 无序版的ma…
阅读更多...
C语言 数组

C语言 数组

C语言 数组一、一维数组1. 数组的创建方式程序清单1程序清单22. 计算数组的元素的个数3. 数组在内存中的存储方式二、二维数组1. 二维数组的创建方式2. 计算二维数组的行和列3. 二维数组在内存中的存储方式三、数组名的含义总结数组名的应用场景数组名作为函数参数一、一维数组…
阅读更多...
22.11.16打卡 mysql学习笔记

22.11.16打卡 mysql学习笔记

马上要考试了, 越到考试越想玩, 烦躁烦躁烦躁, 没学多少, 争取明天把mysql基础篇学完 DCL介绍 2022年11月16日 14:54 DCL主要用来处理数据库有哪些用户可以访问, 每个用户具有什么样的权限 用户管理 2022年11月16日 15:20 所有用户的数据都存放在系统数据库mysql中的user表…
阅读更多...
Python是什么？要如何学习？

Python是什么？要如何学习？

Python 是荷兰人 Guido van Rossum &#xff08;吉多范罗苏姆&#xff0c;中国程序员称其为“龟叔”&#xff09;在 1990 年初开发的一种解释型编程语言。 Python 的诞生是极具戏曲性的&#xff0c;据 Guido 自述记载&#xff0c;Python 语言是在圣诞节期间为了打发无聊的时间而…
阅读更多...
基于全景相机的视觉里程计算法研究

基于全景相机的视觉里程计算法研究

一、视觉里程计 视觉里程计技术首先建立相机的成像模型&#xff0c;接着通过标定算法计算相机参数&#xff0c;最后建立相邻图像的关联并估计相机运动轨迹。 1.1相机在空间中运动的描述 描述相机在三维空间中的运动状态&#xff0c;即求解相机在空间中不同时刻下的位姿关系。相…
阅读更多...
假冒网站引发多重安全风险 | 官方严正声明：切勿在非官方渠道购买或下载 Navicat 软件

假冒网站引发多重安全风险 | 官方严正声明：切勿在非官方渠道购买或下载 Navicat 软件

Navicat 严正声明 近期&#xff0c;有关于 Navicat 假冒网站的事件&#xff0c;不法分子通过仿制官方网站&#xff0c;诱导用户下载盗版软件。Navicat 官方已正式向国内监管部门举报&#xff0c;提请将该不法网站下架。目前&#xff0c;监管部门已介入调查中。 我司呼吁广大用…
阅读更多...
这次，听人大教授讲讲分布式数据库的多级一致性｜TDSQL 关键技术突破

这次，听人大教授讲讲分布式数据库的多级一致性｜TDSQL 关键技术突破

近年来&#xff0c;凭借高可扩展、高可用等技术特性&#xff0c;分布式数据库正在成为金融行业数字化转型的重要支撑。分布式数据库如何在不同的金融级应用场景下&#xff0c;在确保数据一致性的前提下&#xff0c;同时保障系统的高性能和高可扩展性&#xff0c;是分布式数据库…
阅读更多...
C语言之详解内存操作函数

C语言之详解内存操作函数

个人主页&#xff1a;平行线也会相交 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 平行线也会相交 原创 收录于专栏【C/C】 目录前言memcpy模拟实现memmove模拟实现memcmpmemset前言 memcpy叫做内存拷贝&#xff0c;memmove叫做内存移动&#xff0c;memc…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023