简单方法查找邻接矩阵有向图的有序集合

简单方法判断邻接矩阵的有向图是否有环 简单方法判断邻接矩阵的有向图是否有环求解思路实现代码如有不同见解,欢迎讨论 求解思路 1.统计所有节点的出度及其前序节点,初始化一个空的访问集合; 2.将出度为零的节点放入访问集合,并将其前序节点的出度数减1; 3.重复第2步骤,直到所有节点从头到尾完整遍历一遍; 4.判断已访问节点个数是否等于节点个数,是则有向图无环,否则有向图有环。 实现代码 /** * 判断有向图是否有环 ... 阅读详情

简单方法查找邻接矩阵有向图的有序集合

求解思路

1.统计所有节点的出度及其前序节点,初始化一个空的访问集合;
2.将出度为零的节点放入访问集合,并将其前序节点的出度数减1;
3.重复第2步骤,直到所有节点从头到尾完整遍历一遍;
4.判断已访问节点个数是否等于节点个数,是则有向图无环,否则有向图有环。

实现代码

方法一:

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class AlgorithmUtil {
    /**
     * 查找有向图的有序集合,如果有环返回空数组
     * 根据每个节点的入度和出度计算,把出度为零的依次去掉并更改其前序节点的出度个数,统计最后访问过的节点
     */
    public static int[] findSequence(int[][] graph) {
        int nodeNum = graph.length;
        // 记录每个有入度的节点,及其所有的前序节点
        Map<Integer, List<Integer>> inEdge = new HashMap<>(nodeNum);
        // 记录每个节点的出度个数
        int[] outEdgeNum = new int[nodeNum];
        // 初始化数据
        for (int i = 0; i < nodeNum; i++) {
            for (int j = 0; j < nodeNum; j++) {
                if (graph[i][j] != Integer.MAX_VALUE) {
                    outEdgeNum[i]++;
                    if (inEdge.get(j) == null) {
                        List<Integer> list = new ArrayList<>();
                        list.add(i);
                        inEdge.put(j, list);
                    } else {
                        inEdge.get(j).add(i);
                    }
                }
            }
        }

        // 已访问的节点个数
        List<Integer> visitedList = new ArrayList<>(nodeNum);
        // 循环遍历所有节点的出度
        while (visitedList.size() < nodeNum) {
            for (int i = 0; i < nodeNum; i++) {
                if (outEdgeNum[i] == 0 && !visitedList.contains(i)) {
                    visitedList.add(i);
                    for (int temp = 0; inEdge.get(i) != null && temp < inEdge.get(i).size(); temp++) {
                        outEdgeNum[inEdge.get(i).get(temp)]--;
                    }
                    break;
                }
                if ((i == nodeNum - 1) && visitedList.size() != nodeNum) {
                    return new int[] {};
                }
            }
        }
        // 反转集合元素
        Collections.reverse(visitedList);
        int[] result = visitedList.stream().mapToInt(Integer::valueOf).toArray();
        return result;
    }
}

性能优化

方法一虽好但是使用集合太多,性能有瓶颈。优化方法是减少集合使用。


import java.util.HashMap;
import java.util.Map;
import java.util.HashSet;
import java.util.Set;

public class AlgorithmUtil {
    /**
     * 查找有向图的有序集合,如果有环返回空数组
     * 根据每个节点的入度和出度计算,把出度为零的依次去掉并更改其前序节点的出度个数,统计最后访问过的节点
     */
    public static int[] findSequence(int[][] graph) {
        int nodeNum = graph.length;
        // 记录每个有入度的节点,及其所有的前序节点
        Map<Integer, List<Integer>> inEdge = new HashMap<>(nodeNum);
        // 记录每个节点的出度个数
        int[] outEdgeNum = new int[nodeNum];
        // 初始化数据
        for (int i = 0; i < nodeNum; i++) {
            for (int j = 0; j < nodeNum; j++) {
                if (graph[i][j] != Integer.MAX_VALUE) {
                    outEdgeNum[i]++;
                    if (inEdge.get(j) == null) {
                        List<Integer> list = new ArrayList<>();
                        list.add(i);
                        inEdge.put(j, list);
                    } else {
                        inEdge.get(j).add(i);
                    }
                }
            }
        }

        int[] visited = new int[nodeNum];
        int index = 0;
        Set<Integer> visitedSet = new HashSet<>(nodeNum);
        while (index < nodeNum) {
            for (int i = 0; i < nodeNum; i++) {
                if (outEdgeNum[i] == 0 && !visitedSet.contains(i)) {
                    visited[index++] = i;
                    visitedSet.add(i);
                    for (int temp = 0; inEdge.get(i) != null && temp < inEdge.get(i).size(); temp++) {
                        outEdgeNum[inEdge.get(i).get(temp)]--;
                    }

                    break;
                }
                if ((i == nodeNum - 1) && visitedSet.size() != nodeNum) {
                    return new int[] {};
                }
            }
        }
        reverseArray(visited);
        return visited;
    }
	
	/**
     * 数组反转
     * @param array 数组
     */
    private static void reverseArray(int[] array) {
        for (int i = 0; i < array.length / 2; i++) {
            int temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
    }
}

测试用例

import org.junit.Test;

public class AlgorithmUtilTest {

    @Test
    public void findSequence() {
        int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, NAN}};
        int[] resp = AlgorithmUtil.findSequence(graph);
        int[] goal = new int[] {0, 1, 2, 3};
        int[] goal2 = new int[] {0, 2, 1, 3};
        assert isEqual(resp, goal) || isEqual(resp, goal2);
    }

    @Test
    public void findSequence2() {
        int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {1, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, NAN}};
        int[] resp = AlgorithmUtil.findSequence(graph);
        int[] goal = new int[] {};
        assert isEqual(resp, goal);
    }

    @Test
    public void findSequence3() {
        int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {1, NAN, NAN, NAN}};
        int[] resp = AlgorithmUtil.findSequence(graph);
        int[] goal = new int[] {};
        assert isEqual(resp, goal);
    }

    @Test
    public void findSequence4() {
        int[][] graph = new int[][] {{NAN, 1, NAN, NAN, NAN, NAN, NAN}, {NAN, NAN, NAN, NAN, NAN, NAN, NAN},
            {1, NAN, NAN, 1, NAN, NAN, NAN}, {1, NAN, NAN, NAN, NAN, NAN, NAN}, {NAN, NAN, 1, NAN, NAN, NAN, NAN},
            {NAN, NAN, 1, NAN, 1, NAN, NAN}, {NAN, NAN, NAN, NAN, NAN, 1, NAN}};
        int[] resp = AlgorithmUtil.findSequence(graph);
        int[] goal = new int[] {6, 5, 4, 2, 3, 0, 1};
        assert isEqual(resp, goal);
    }

    private boolean isEqual(int[] numA, int[] numB) {
        if (numA.length == numB.length) {
            for (int i = 0; i < numA.length; i++) {
                if (numA[i] != numB[i]) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
}

知识背景

leetcode 210. 课程表 II
简单方法判断邻接矩阵的有向图是否有环

如有不同见解,欢迎留言讨论

计算机考研考博经典考题汇总(一次刷新世界观-我相信VIP总是有原因的) 操作系统 操作系统的特点? – 共享:资源可被多个并发执行的进程使用 – 并发:可以在同一时间间隔处理多个进程,需要硬件支持 – 虚拟:将物理实体映射成为多个虚拟设备 – 异步:进程执行走走停停,每次进程执行速度可能不同,但OS需保证进程每次执行结果相同 进程的三个组成部分? 程序段、数据段、PCB(Process Control Block) 并发与并行区别? 并发:同一间隔 并行:同一时刻 进程切换的过程? 保持处理机上下文 -> 更新PCB -> 把PCB移入相应队列(就绪、阻塞) -&g 阅读详情

相关推荐

17、算法概念、正确性证明与图灵机模型解析

本文深入探讨了算法的基本概念及其正确性证明方法,重点分析了沃舍尔算法在有向图可达性计算中的应用与复杂度。同时介绍了图灵机模型的结构、工作原理及其在形式化算法中的作用,并结合矩阵运算、多矩阵相乘的最优顺序等问题展示了算法设计与优化的实际案例。通过对f(N)、g(N)、h(N)等函数的数学推导,进一步揭示了嵌套循环的时间复杂度规律。整体内容构建了从理论到实践的完整算法知识体系。

tensorflowjs6的博客 73

图论基础(一)

图论基础(一)有向图定义​ 有向图G是一个二元组(V, E),记为G=(V, E)。 其中V是有向图G的顶点集合,是一个有限集合,元素为顶点;E是有向图G的边集合,元素为边,边也是一个二元组(u, v),其中u,v是有向图G的顶点集合中的元素,(u, v)在这里是有方向的边,以u为起点,指向v的一条有向路径。u可以与v相同,代表自身指向自身的一个自环路径。​ 假定存在有向图G=(V

oYinGui1 1306

深度搜索邻接矩阵深度搜索邻接矩阵

template class Graph; template class Graphmtx;

有向图和无向图的表示方式(邻接矩阵,邻接表)

有向图和无向图的表示方式(邻接矩阵,邻接表):无向图,无向网,有向图,有向网的实现

weixin_69884785的博客 4万+

数据结构--有向图

数据结构--有向图的深度遍历。打印遍历的过程。

Vue3实战:集成bpmn-js与Activiti工作流引擎的完整指南

本文详细介绍了如何在Vue3项目中集成bpmn-js流程图编辑器与Activiti工作流引擎,构建一个完整的前端流程设计器。文章重点解析了Vue3响应式系统与bpmn-js集成的核心陷阱及解决方案,并提供了属性面板配置、XML命名空间适配、撤销重做等实用功能的完整实现指南,帮助开发者高效完成工作流系统的前端开发。

weixin_29009881的博客 214

第10章:有向图和偏序

关系R:A →A与A为顶点的有向图相同。自反性R是自反的,当R中的每个顶点都有一个自循环。非自反性R是非自反的,当R中没有自循环。对称性R是对称的,当如果在R中存在由x到y的边,那么同样也存在从y回到x的边。非对称性R是非对称的,当在R中的两个顶点之间最多存在一条有向边,且不存在自循环。反对称性R是反对称的,当等价的,两个不同的顶点之间至多有一条有向边,但可以存在自循环。传递性R是传递的,当如果由u到v存在一条正长度通路,那么从u到v就存在一条边。线性。

houyiming 2966

基于小波变换的信号降噪处理及仿真研究_信号处理方法推荐--1(转载自用,侵删)...

综述作者:aresmiki链接:https://www.zhihu.com/question/23701194/answer/167005497来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。非平稳信号处理应该是现在信号处理技术最新的也是最热的研究方向了,信号处理方法从最早的时域统计到傅里叶变换的频域分析,是人们认识信号本质的一次巨大飞跃,给了分析人员换个角度看世界的...

weixin_32144483的博客 1252

邻接矩阵 & 邻接表

Java、邻接矩阵和邻接表。

m0_63911891的博客 4780

Unity ProBuilder(自己创建斜面、拐角)

ProBuilder基础实例

weixin_56537692的博客 1552

售货机非现金支付开发指南:MDB协议下VPOS刷卡器的那些坑

本文深入探讨了MDB协议下非现金支付设备的开发实践,重点解析了NAYAX VPOS刷卡器的集成难点与解决方案。从RS232通信参数配置到Always idle功能实现,提供了一套完整的售货机支付系统开发指南,帮助开发者规避常见陷阱,提升设备兼容性与交易稳定性。

weixin_29258297的博客 138

图【数据结构】

图的抽象数据类型定义如下:ADT Graph数据对象V:具有相同特性的数据元素的集合,称为顶点集。数据关系R:R={VR}VR={<v,w>表示从v到w的弧,P(v,w)定义了弧<v,w>的信息基本操作P::图的创建操作。初始条件:无。操作结果:生成一个没有顶点的空图G。:求图中的顶点v的值。初始条件:图G存在,v是图中的一个顶点。操作结果:生成一个没有顶点的空图G。初始条件:V是图的顶点集,VR是图中弧的集合。操作结果:按V和VR的定义构造图G。

m0_73065213的博客 1584

LeGO-LOAM运行kitti数据集

文章目录1. kitti-lego-loam2. 改动3. 实验结果4. evo轨迹测评 1. kitti-lego-loam 链接:kitti-lego-loam kitti-lego-loam提供了将kitti序列转化成rosbag的代码,在kittibag中. 需要注意下数据文件的存放顺序,以00序列为例: datafolder          |____results          &

Zlp19970106的博客 8706

邻接矩阵与邻接表:图存储结构选型与工程实践指南

图作为一种描述实体间复杂关系的数据结构,是解决社交网络、路径规划、知识图谱等问题的核心。其存储方式的选择,直接决定了后续算法的效率上限。图的存储本质上是如何在计算机中高效表示顶点和边的关系,核心在于平衡空间与时间的开销。邻接矩阵使用二维数组,提供O(1)的快速邻接查询,但空间复杂度为O(|V|²),适用于稠密图或小规模图。邻接表则为每个顶点维护一个邻居列表,空间复杂度为O(|V|+|E|),在遍历和内存效率上优势明显,是处理稀疏图和大规模图的默认选择。在工程实践中,需要根据图的稠密度、核心操作(如频繁查询或

weixin_34357436的博客 368

神联动:LSTM+卡尔曼滤波!一区大门轻松开!

近来热度飙升,成为时间序列预测和状态估计等领域的香饽饽,非常好发高区!主要在于:这两者结合,不仅能提高模型预测准确性;还能拓展应用场景,为我们的论文创新提供发挥空间,且当下还在蓝海阶段,还不算卷。具体点说:卡尔曼滤波擅长处理线性状态估计和噪声,能使LSTM更好地适应动态环境的变化,减少噪声干扰,降低预测误差。而LSTM通过捕捉长期依赖关系,擅长处理非线性时间序列,能够弥补卡尔曼滤波在这方面的不足,从而把应用场景从传统的状态估计,延伸到金融预测、工业检测、自动驾驶等任务。

2401_82426425的博客 2211

Qt Creator 下载和安装

在线安装程序是一个小型的安装程序,它将在您的计算机上下载和安装 Qt Creator。离线安装程序是一个较大的安装包,您可以将其保存在本地,并在没有网络连接的情况下安装 Qt Creator。在 Qt 官方网站上,您可以找到 Qt Creator 的下载页面。Qt Creator 是一款跨平台的集成开发环境(IDE),用于开发基于 Qt 框架的应用程序。在这一步中,您可以选择是否安装 Qt Creator 的附加组件。一旦您完成了组件的选择,安装程序将开始将 Qt Creator 安装到您的计算机上。

HackLogic的博客 6825

寒假训练营 第5节 数据结构基础(笔记)

寒假训练营 第5节 数据结构基础 笔记

m0_73870738的博客 141

【SAP HANA 46】关于HANA CPU高峰到 80-100%

关于HANA CPU高峰到 80-100%

探索 Java 编程的技巧、最佳实践和解决方案。本博客提供针对 Java 开发者的实用指南,涵盖从基础到高级话题,旨在提升编程效率和技能。 432

数据逻辑讨论计算机,计算机二级考试复习资料之软件技术基础

全国计算机等级考试二级考试复习备考资料,列及了软件设计基础中的一些名词解释和概念。计算机二级考试复习资料之软件技术基础1.1 数据结构的基本概念数据结构 讨论计算机系统中数据的组织及其相互关系。数据 客观事物采用计算机进行识别、存储和加工所进行的描述。数据的基本单位是数据元素(有的书上将其称为数据节点)。数据结构的三个层次 数据的逻辑结构、数据的存储结构、数据的草组集合。 逻辑结构 线性结...

weixin_29416253的博客 184

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

算法技术手册 摘录

黑客帝国:Neo,是这个问题驱使着我们,是这个问题带你来到这儿。你知道这个问题,我也是。第一部分第1章 算法真的很重要malloc()一个包装了系统内存分配函数的函数。free()一个包装了系统内存回收函数的函数。exit()一个包装了系统退出函数的函数。如果需要,尽可能用实践检

samozihu的专栏 1029

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

数据结构和算法

简单算法时间复杂度分析: 1.大O描述的是算法的运行时间与输入数据的关系 2.渐进时间复杂度,描述的是n趋于无穷时时间复杂度 动态规划: 最短路径: 松弛操作: dijkstra单元最短路径:不能处理图中带有负权边,复杂度O(ELogV) Bellman-Ford单元最短路径:不能处理带有负权环,可以判断,复杂度O(EV) 拥有负权环的图,不再拥有最短路径 Floyed算法...

425

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

数据结构(c语言版)

(1)结构体struct。

superDoufu的博客 568

数据结构与STL —— 非线性数据结构

非线性数据结构中的数据元素之间不存在顺序关系,或者说存在多个直接前驱和后继,或者没有前驱和后继。数据元素排列成分支结构或者多维结构。常见的非线性数据结构包括树、图等。

m0_46181435的博客 1133

《学习JavaScript数据结构与算法》核心知识点梳理

这本《学习JavaScript数据结构与算法》是前端和Node.js开发者入门数据结构与算法的经典读物。它的核心价值在于使用JavaScript这门熟悉的语言,来揭示计算机科学中基础且重要的概念。

宝青书坊 1582

【论文阅读】Learning Convolutional Neural Networks for Graphs

出版:ICML 2016 原文:http://211.81.63.130/cache/2/03/proceedings.mlr.press/cb5795e96aa42362f86e2ba3a13c32af/niepert16.pdf 卷积神经网络(CNN)可以提取图像像素点邻域的信息,从而抽取空间特征。而CNN处理的图像数据中像素点是排列成整齐的矩阵的,也就是Euclidean Structure结构。而对于graph这种拓扑结构,每个结点的度都不一样,原始的CNN就没办法处理了。这篇论文就提出了一种一般性

weixin_43751558的博客 669

[Data Structure & Algorithm] 有向无环图的拓扑排序及关键路径

基本名称 有向无环图 - DAG (Directed Acycline Graph) 如果图的邻接矩阵中,对角线以上(或以下)均为零,则说明该有向图为无环图;反之,不一定成立 顶点表示的活动网 - AOV网 (Activity On Vertex Network) 弧上没有权值 通常用于表示流程图 弧表示的活动网 - AOE网 (Activity On Edge) 弧上的权值 - 活动...

weixin_30783913的博客 186
上一篇: 简单方法判断邻接矩阵的有向图是否有环
zas765
博客等级 码龄15年 0粉丝 3原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值