精华内容
下载资源
问答
  • 有向图拓扑排序

    2021-05-27 21:22:40
    本文介绍有向图拓扑排序算法的思路及代码实现,首先讲解什么是拓扑排序,其次介绍实现拓扑排序需要的检测有向图是否有环的算法及顶点排序算法,最终实现有向图的拓扑排序。 一、什么是拓扑排序? 给定一副有向图,...

    有向图拓扑排序

    前言

    本文介绍有向图拓扑排序算法的思路及代码实现,首先讲解什么是拓扑排序,其次介绍实现拓扑排序需要的检测有向图是否有环的算法及顶点排序算法,最终实现有向图的拓扑排序。

    一、什么是拓扑排序?

    • 给定一副有向图,将所有的顶点排序,使得所有的有向边均从排在前面的元素指向排在后面的元素,此时就可以明
      确的表示出每个顶点的优先级。如对下图进行拓扑排序:
      在这里插入图片描述
    • 拓扑排序结果为:
      在这里插入图片描述
    • 根据拓扑排序的概念,如果对有向图进行拓扑排序,那么图中必须没有环,否则,就不能进行拓扑排序,然后在图中无环的情况下,再进行顶点排序,最终实现拓扑排序。

    二、检测有向图中是否有环

    • 算法思路:基于深度优先搜索算法检测图中是否有环。1. 定义boolean辅助数组onStack,以栈的思想标识顶点是否在搜索中;2. 在深度优先搜索中,不断检测当前搜索的顶点是否在栈中(即当前顶点的值是否为true,如果为true,则在栈中,否则不在栈中),如果在栈中,说明该顶点被重复搜索到,代表图中有环;3. 每个顶点深度优先搜索完成,onStack需要出栈(即将当前索引对应的值修改为false),为下个顶点搜索做准备
    • 示例:
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 代码实现
    public class DirectedCycle {
        private boolean[] marked;//索引代表顶点,用于标识顶点是否搜索过,是深度优先搜索的复杂数组
        private boolean hasCycle;//记录图中是否有环
        private boolean[] onStack; //索引代表顶点,使用栈的思想,记录当前顶点有没有已经处于正在搜索的栈上,如果有,则证明有环。
    
        //创建一个检测环对象,检测图G中是否有环
        DirectedCycle(DirectGraph G)
        {
            this.marked=new boolean[G.V()];//用于标识顶点是否搜索过
            this.hasCycle=false;
            this.onStack=new boolean[G.V()];//用于标识顶点是否在搜索中
    
            //遍历所有顶点,将未搜索过的顶点作为入口,进行深度优先遍历,检测是否有环,一旦检测到有环,则结束;
            //因为对于不连通图,有很多个子图,也许某个子图存在环,因此,要对每个子图进行深度优先遍历检测,而不能只检测某一个子图。
            for (int v = 0; v < G.V(); v++) {
                if (!marked[v])
                    dfs(G,v);//每次搜索一个子图,判断子图内是否有环,如果没环,继续搜索下一个子图(一次搜索后,未搜索的顶点一定在另一个子图中)
            }
        }
    
        //基于深度优先搜索,检测图G中是否有环
        private void dfs(DirectGraph G,int v)
        {
            //1.当前顶点标记为已搜索
            marked[v]=true;
            //2.当前顶点入栈
            onStack[v]=true;
            //3.递归深度优先遍历,检查遍历结点是否已经在栈中,如果在栈中,则表明该顶点被两次搜索到,证明有环,则结束
            for (Integer w : G.adj(v)) {
                if (!marked[w])
                    dfs(G,w);
                //如果该顶点已经被搜索过,且如果该顶点在搜索的路径上,则代表又一次搜索到该顶点,证明有环,结束搜索。
                if (onStack[w]) {
                    hasCycle = true;
                    return;
                }
            }
            //4.当前顶点出栈,为下一个节点作为入口,检测是否有环做准备(为什么需要这样,图2.png可以解释)
            onStack[v]=false;
        }
        //判断当前有向图G中是否有环
        public boolean hasCycle()
        {
            return hasCycle;
        }
    }
    

    代码中为什么每个顶底深度优先搜索完成后onStack需要出栈,下图可以解释:
    在这里插入图片描述

    三、基于深度优先的顶点排序

    • 拓扑排序使得所有的有向边均从排在前面的元素指向排在后面的元素,要实现这一需要,可以通过顶点排序进行实现。
    • 顶点排序算法思路:1. 定义栈stack用于存储顶点排序的结果;2. 基于深度优先搜索算法,每个顶点深度优先搜索完成后,将该顶点入栈;3. 依次弹出栈中顶点,即为满足拓扑排序要求的顶点序列。
    • 顶点排序示例:
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 代码实现
    public class DepthFirstOrder {
        private boolean[] marked;//索引代表顶点,值表示当前顶点是否已经被搜索
        private Stack<Integer> reversePost;//使用栈,存储顶点序列,打印出栈中的顶点,即是排序后的顶点
    
        public DepthFirstOrder(DirectGraph G)
        {
            //初始化辅助变量
            this.marked=new boolean[G.V()];//默认全部赋值为false
            this.reversePost=new Stack<Integer>();
            //对每一个未搜索过的顶点进行深度优先遍历
            for (int v = 0; v < G.V(); v++) {
                if (!marked[v])
                    dfs(G,v);
            }
        }
    
        //基于深度优先搜索,生成顶点线性序列
        private void dfs(DirectGraph G,int v)
        {
            //1. 将当前顶点标记为已搜索
            marked[v]=true;
            //2. 遍历当前顶点的邻接表,对邻接表中未搜索的顶点递归调用深度优先搜索
            for (Integer w : G.adj(v)) {
                if(!marked[w])
                    dfs(G,w);
            }
            //3. 当前顶点v深度优先搜索完毕后,入栈
            reversePost.push(v);
        }
        //获取顶点线性序列
        public Stack<Integer> reversePost()
        {
            return reversePost;
        }
    }
    

    四、拓扑排序实现

    • 实现了检测是否有环和顶点排序算法,也就完成了拓扑排序,拓扑排序是对上面两个算法的封装。
    • 拓扑排序算法步骤:1. 定义栈用于存储拓扑排序顶底;2. 检测图中是否有环;3. 若有环则不做拓扑排序,若无环则对图进行顶点排序,完成拓扑排序
    • 代码实现
    public class TopoLogical {
        private Stack<Integer> order; //顶点的拓扑排序
    
        public TopoLogical(DirectGraph G)
        {
            //1. 检测是否有环
            DirectedCycle directedCycle = new DirectedCycle(G);
            if (!directedCycle.hasCycle())
            {
                //2. 调用顶点排序算法
                DepthFirstOrder depthFirstOrder = new DepthFirstOrder(G);
                this.order=depthFirstOrder.reversePost();
            }
        }
    
        //判断图G是否有环
        public boolean isCycle()
        {
            return order==null;
        }
        //获取拓扑排序的所有顶点
        public Stack<Integer> order()
        {
            return order;
        }
    }
    
    展开全文
  • 链式前向星是一种比较好用的存有向图的方法,相比邻接矩阵与邻接表,链式前向星有着更大的优势。但是相比于前两种存图方式,链式前向星的代码难度是比较大的,笔者在学习时也花了不少时间。而看了很多博客虽然写的很...

    c++链式前向星代码分析(代码逐句分析)

    链式前向星(优化后的邻接表)是一种比较好用的存有向图的方法,相比邻接矩阵,链式前向星有着更大的优势。但是相比于前两种存图方式,链式前向星的代码难度是比较大的,笔者在学习时也花了不少时间。而看了很多博客虽然写的很好,但如果面对真正的纯小白(比如我),还是有点难以理解的。

    链式前向星概念解释

    在链式前向星中,我们需要4个数组与一个常量:h[N], ne[N], e[N](或者写为to[N]), w[N],cnt;
    N代表边的编号,由cnt确定
    其中,ne[N], e[N](或者写为to[N]), w[N],可以用结构体封装,熟练了也可以不封装,看个人喜好。ne[i], e[i](或者写为to[i]), w[i],共同确定一条编号为i的边

    1.e[i](或者写为to[i]):编号为i的边的终点为e[i]。
    2. w[i]:编号为i的边的长度为w[i]。
    3. h[x]:(重点) 以x为起点的编号最大的边的编号为h[x],这里的x不要和上面的i混淆,也可以理解为最后存进图的以x为起点的边的编号为h[x]。初始化为-1,随着点的录入而更新。
    4. ne[i](或写为next[i])(重点):当第i点录入边a---->b时,用ne[i]来记录下来当前的h[a],ne[i]代表在边i之前一个被存进图中的以a为起点的编号。用处在之后会解释到
    5. cnt:用来记录上面的i,每录入一条边,cnt++

    链式前向星功能实现解释

    在了解了链式前向星的基本概念后,我们要怎么才能实现图的遍历呢?
    首先,我们给出有向图的一部分,红字代表边的编号(即i),假设所有边的长度为1,即所有w[i]=1,录入图的顺序为1,3,7;
    在这里插入图片描述
    此时:
    h[1]=7;
    ne[1]=-1; ne[3]=1 ; ne[7]=3 ;
    e[1]=3; e[3]=5; e[7]=6;

    至于为什么是这样,可以看看上下文解释

    然后,我们要找出以1为起点的所有点该怎么办呢?

    1. 找到h[1],1代表起点,h[1]=7,我们找到了边7
    2. 通过e[7]=6,我们知道了边7的终点为6,我们就这样找到了边1----->6,这条边编号为7
    3. 我们通过ne[7]=3,找到了同样起点为1的边3
    4. 通过e[3]=5,我们知道了边3的终点为5,我们就这样找到了边1----->6,这条边编号为3
    5. 重复3、4找到边1----->3,编号为1
    6. 查找到ne[1]=-1,我们知道了边1是最早被录入的以1为起点的边了,代表我们已经找完了所有以1为起点的边了,结束搜索。

    通过这样的方法,我们只需要遍历所有图中所有的点x,寻找h[x]后按照上述步骤来遍历就可以遍历一个有向图中的所有的边了

    链式前向星代码实现

    核心代码实现

    //初始化
    const int N=1e5+7;
    int e[N], ne[N], h[N],w[N] cnt = 1;  //链式前向星
    
     for (int i = 1; i <= n; i++)  //把所有head初始化为-1,代表以i为起点的序号最小的边的next值为-1
         h[i] = -1;
         
    
    //存边
    void add(int x,int y,int z)  // 存x----->y,长度为z的边
    {
    		e[cnt]=y;
    		w[cnt]=z;
    		ne[cnt]=h[x];
    		h[x]=cnt;
    		cnt++;
    }
    
    //找边
    for(int i=1;i<=n;i++)  //枚举图中所有点
    {
    	for(int j=h[i];j!=-1;j=ne[j])
    	{
    		int k=e[j];   //这样就枚举完了所有边j:i------>k
    		······
    	}
    }
    

    全部代码实现,这里也写一下结构体写法

    #include<iostream>
    using namespace std;
    
    struct Edge  //每一个edge代表一条边,数组序号代表编号
    {
    	int next;  //上一个同起点的边的序号
    	int to;  //这条边指向的点
    	int w;  //这条边的长度
    };
    
    Edge edge[101];  //先定义个101条边
    
    int head[101];  //head[i],代表以i为起点的边的最大序号是head[i],随着数组的输入而更新
    
    int cnt = 1;   //工具变量,记录边的序号,顺便(真的是顺便,这个功能非必要)记录了有几条边,add函数用一次自加一次
    
    void add(int u, int v, int w)  //输入从u到v的长度为w的边
    {
        edge[cnt].w = w;  //第cnt条边长为w
        edge[cnt].to = v;  //第cnt条边指向点v
        edge[cnt].next = head[u];  //上一条以u为起点的最大序号的边的序号是head[u],每一条边都记录下了上一个同起点的边的序号,用next
        head[u] = cnt++;  //现在以u为起点的最大序号的边的序号是cnt了
    }
    
    int main()
    {
        for (int i = 0; i < 101; i++)  //把所有head初始化为-1,代表以i为起点的序号最小的边的next值为-1
            head[i] = -1;
    
        int m, n;  //m个点,n条边
        cin >> m >> n;
    
        for (int i = 1; i <= n; i++)  //边的输入
        {
            int u, v,w;
            cin >> u >> v>>w;
            add(u, v, w);
        }
    
        for (int i = 1; i <= m; i++)  //输出每个以i为起点的所有线
        {
            for (int j = head[i]; j != -1; j=edge[j].next)  //从以i为起点的最大序号边开始,通过每条边的next递推从而依次按边的序号从大到小输出边,到j=-1就说明输出完了
            {
                cout <<"这一条边是  "<< i << " --->" << edge[j].to << "  长度为" << edge[j].w << endl;
            }
        }
        return 0;
    }
    

    例如,如果输入

    5 7
    1 5 3
    2 5 4
    3 5 1
    3 2 4
    3 6 6
    4 2 1
    5 4 2
    

    程序将会输出

    这一条边是  1 --->5  长度为3
    这一条边是  2 --->5  长度为4
    这一条边是  3 --->6  长度为6
    这一条边是  3 --->2  长度为4
    这一条边是  3 --->5  长度为1
    这一条边是  4 --->2  长度为1
    这一条边是  5 --->4  长度为2
    

    这样链式前向星的问题就这样解决啦,是不是很简单(不是

    作者:Avalon Demerzel,喜欢我的博客就点个赞吧,更多图论与数据结构知识点请见作者专栏《图论与数据结构》

    展开全文
  • 一、实验目的及要求 ... 在带权的有向图上求解从某一原点出发到其余顶点的最短路径。 以界面的形式展现出相关的选项。 二、实验代码 #include <stdio.h> #include <stdlib.h> #define INFIN

    一、实验目的及要求

    分别构造四种类型图的邻接矩阵存储结构和邻接表存储结构。

    1. 输出构造的图。
    2. 分别实现图的DFS和BFS算法(存储结构任意)。
    3. 在给定的连通网络上求解最小生成树(Prim算法和Kruscal算法任选)。
    4. 在给定的有向带权图上实现求关键路径的算法。
    5. 在带权的有向图上求解从某一原点出发到其余顶点的最短路径。
    6. 以界面的形式展现出相关的选项。

    二、实验代码

    #include <stdio.h>
    #include <stdlib.h>
    #define INFINITY   10000
    #define MAX_VERTEX_NUM    20//最大顶点数
    typedef enum {DG, DN, UDG, UDN} GraphKind;
    typedef struct ArcCell{//弧的信息结构
                  int       adj;//顶点类型,对无权图,用1表示相邻,0表示否,对带权图,则为权值
                  char      *info;
    }ArcCell, AdjMatrix[MAX_VERTEX_NUM ] [MAX_VERTEX_NUM];//二维数组
    typedef struct {//图的结构
                  char    vex[MAX_VERTEX_NUM];//顶点向量
                  AdjMatrix  arcs;//邻接矩阵,二维数组
                  int   vexnum, arcnum;//图当前的顶点数与弧数
                  GraphKind  kind;
    }MGraph;//图的邻接矩阵结构体定义 
    typedef struct ArcNode{
    	int adjvex;//邻接点域指示与顶点vi邻接的点
    展开全文
  • 代码 测试数据 提示:由于拓扑排序的检测方式不涉及到边权或点权,所以拓扑序列中的正环和负环都能够被检测出来。检测可达负环可以用Bellman-Ford或者SPFA。 算法主要步骤 1. 记录每个结点的入度,设置一个队列...

    目录

    算法主要步骤

    代码

    测试数据


    提示:由于拓扑排序的检测方式不涉及到边权或点权,所以拓扑序列中的正环和负环都能够被检测出来。检测可达负环可以用Bellman-Ford或者SPFA。

    算法主要步骤

    1. 记录每个结点的入度,设置一个队列,专门存放入度为0的结点,设置一个整型计数变量inqNum,记录加入过队列的结点的个数。

    2. 首先将所有的入度为0的点放入队列中,进入while循环,条件是队列不为空,对于队列中的每一个点,都对齐后继结点的入度进行减一操作,如果在那之后该后继节点的入度变为0,则将其加入队列。

    3. 注意inqNum的维护,不是在将一个结点放入队列时增加,而是在它弹出后、处理了它的所有后继节点后增加,这样只要写一处代码。出了while循环后对inqNum进行判断,如果恰好等于节点个数说明图中没有环,否则说明有环(环上的结点由于永远不会入度为0所以入不了队列)

    代码

    #include<cstdio>
    #include<algorithm>
    #include<queue>
    
    using namespace std;
    
    const int maxn = 1010;
    
    int vNum;
    vector<int> G[maxn];
    int inDegree[maxn] = {0};//记录每个点的入度 
    int inqNum = 0;
    
    bool topoSort(){
    	queue<int> Q;
    	for(int i=0;i<vNum;i++){
    		if(inDegree[i]==0){
    			Q.push(i);
    		}
    	}
    	while(!Q.empty()){
    		int u = Q.front();
    		Q.pop();
    		for(int i=0;i<G[u].size();i++){
    			int v = G[u][i];
    			inDegree[v] --;
    			if(inDegree[v]==0){
    				Q.push(v);		
    			}
    		}
    		inqNum ++;
    	}
    	
    	if(inqNum==vNum)return true;
    	else return false; 
    }
    
    
    int main(){
    	int eNum;
    	scanf("%d %d",&vNum,&eNum);
    	
    	int v1,v2;
    	while(eNum--){
    		scanf("%d %d",&v1,&v2);
    		inDegree[v2] ++;//v2不会是起点了 
    		G[v1].push_back(v2);
    	}
    	
    	if(topoSort())printf("该拓扑结构不含有环");
    	else printf("该拓扑结构含有环"); 
    	
    
    	return 0;
    }

    测试数据

    第一行是点的个数(从0开始编号)、边的个数

    后面是拓扑序列

    #Case 1 无环

    8 15
    0 1
    1 2
    3 4
    3 7
    4 5
    7 5
    5 6
    0 4
    3 1
    1 4
    1 5
    2 4
    7 2
    2 5
    2 6

    # Case 2 有环

    4 5
    0 1
    1 2
    3 0
    3 2
    2 0

    展开全文
  • 定义了对话框的内容,也就是流程啦下面是表格中操作按钮的代码,相对应的还有一个不同意,但怎么把他们放进一个单元格里呢{title: '操作',key: 'action',fixed: 'right',width: 80,that: this.data1,render: (h,...
  • 1、为什么要有图? 我们已经学过了线性表和树结构,它们都各自的应用场景。 然而线性表局限于一个直接前驱和一个直接后序的关系,也就是说集合中必存在唯一的一个"第一个元素",必存在唯一的一个"最后元素",除了...
  • 解决着色问题 python代码实现

    千次阅读 2021-01-14 20:51:20
    我们都知道,很多问题都可以转化成图着色问题来进行解决,所以本文的例子直接是无向图。二、解决思路不太成熟的想法:要使得相邻点的颜色不同,着色方案很多种,那么究竟哪种着色方案使用的颜色最少呢?首先最开始...
  • 本文给大家介绍CSS如何实现滚动的图片栏(代码实例),一定的参考价值,需要的朋友可以参考一下,希望对你们有所帮助。在一些网站上可以经常看到一些图片进行持续不断的滚动,这个效果可以通过css的动画效果来...
  • 本题要求实现一个函数,输出有向图每个顶点的数据元素的值,以及每个顶点的出度的值。 函数接口定义: 函数接口为: void outdegree(MGraph G); G为采用邻接矩阵作为存储结构的有向图。 裁判测试程序样例: #...
  • stm32入门实验代码编写步骤整理

    千次阅读 2021-01-03 10:47:29
    一、GPIO 的操作步骤 1) 使能 IO 口时钟。 调用函数为 RCC_APB2PeriphClockCmd()。 2) 初始化 IO 参数。 调用函数 GPIO_Init(); 3) 操作 IO。 GPIO_SetBits()、GPIO_ResetBits ()等 二、串口usart **1) 串口...
  • Java实现搜索功能代码详解

    千次阅读 2021-02-12 14:42:49
    首先,我们要清楚搜索框中根据关键字进行条件搜索发送的是get请求,并且是当前页面发送get请求//示例代码 请求路径为当前页面路径 "/product"当我们要实现多条件搜索功能时,可以将搜索条件封装为一个map集合,再...
  • 的最短路径算法(Dijkstra算法)的分析和代码实现
  • 的最小生成树算法(Prim算法)的分析和代码实现
  • 本文面向于那些软件架构师,设计师和开发人员,他们想使用 IBM® Rational® Software Architect 从 Java™ 源代码来逆向工程生成 UML 类和序列。 逆向工程经常被用来从已的源代码中以一种抽象模型 UML 格式来...
  • Android轮播图实现教程

    千次阅读 2021-06-03 07:46:50
    ListView的headerView设置为轮播之后结合上/下拉刷新/加载的模式成为现在大多数APP的一个必须具备的功能,对于许多初学者来说想要实现轮播这样一个集线程睡眠、自动处理、替换过程中刷新UI界面的组合功能非常...
  • Android 购物车实现(思路+步骤+源码)

    千次阅读 多人点赞 2021-01-20 17:47:55
    并且很多公司面试初级Android会问你购物车的实现思路和步骤,第一是想看你是否思路清晰,第二是否过实践。里面的逻辑我相信用过淘宝、天猫、京东等电商APP的都比较清楚,但是写这个功能并不容易,很容易把逻辑写错...
  • 分析功能Client与Server共有功能Client专属功能Server专属功能代码实现 本文是从零开始Web服务器的第二篇,本篇将正式从代码入手讲解整个网络编程 给出笔者学习期间接触到的Web服务器代码(C/C++)连接 ...
  • 频域滤波步骤: 1.给定大小为M×NM\times NM×N的输入图像,将其...如,相当于对h(m)关于y轴对称之后右不断平移x,并求其和f(m)的乘积。如果对称之后,h(m)的图像与h(x) or f(x)重叠,就会产生混叠,影响结果。
  • 按照如上步骤,如果你是个可怜的倒霉蛋子,那么你需要标记遍历完所有的路径才能走出迷宫。 因此,那些靠遍历所有路径但每条路只走一次最终走出迷宫的倒霉蛋都是会数据结构与算法的倒霉蛋,而那些即不会DFS算法又运气...
  • html元素左移代码 html

    千次阅读 2020-12-23 15:10:42
    html文字左移动?这必须在JS中实现,因为CSS无法获取ID属性并做出判断,因此无法用CSS完成。html页面怎么实现把某个元素左移50像素?1。利用CSS中的margin实现了在HTML中定位元素位置并将其左...代码如下。4本段...
  • 百行 HTML5 代码实现四种双人对弈游戏于 丙超2012 年 6 月 28 日发布目标要做一个完整的双人对弈游戏,至少要做如下事情,第一步:绘制棋盘。不同的棋类游戏棋盘不同,这一点需要进行动态处理;第二步:绘制棋子。...
  • 最近看了很多关于css3...先看最终效果:接下来是我书写的步骤:首先是html,分别写出云朵,小鸡的身体,鸡冠,眼睛,嘴巴,腮红,翅膀,鸡爪接下来是css设置样式:先设置整体的背景色,使用的是线性渐变linear-gra...
  • 邻接矩阵(无向图/有向图) 利用数组的方式来存储,适合稠密图的存储,表示方式唯一,但是时间复杂度较高,无向图的邻接矩阵是对称的,可以利用上三角/下三角来压缩存储 邻接表(无向图/有向图) 是顺序存储和链式...
  • 我本着自己的好奇心,实现了一个简易版的老虎机: 老虎机的整体外观样式还是比较好写的,对老虎机的外观布局如果兴趣的话可以直接参考代码,小编就不一一介绍了。文章主要介绍的是老虎机中间三个小格子和机身动画的...
  • 《当人工智能遇上安全》系列博客将详细介绍人工智能与安全相关的论文、实践,并分享各种案例,涉及恶意代码检测、恶意请求识别、入侵检测、对抗样本等等。前一篇文章普及了基于机器学习的恶意代码检测技术,主要参考...
  • 摘要 近年来,由于神经网络在模式识别和数据挖掘领域的应用和其易用性,神经网络已获得了巨大的普及。...在本文中,我们将研究和GNN的定义和基础,并了解神经网络的一些最新应用。 一、什么是
  • 我本着自己的好奇心,实现了一个简易版的老虎机: 老虎机的整体外观样式还是比较好写的,对老虎机的外观布局如果兴趣的话可以直接参考代码,小编就不一一介绍了。文章主要介绍的是老虎机中间三个小格子和机身动画的...
  • 看完这篇教程,你应该可以: 使用 React 脚手架新建一个项目 了解 React 的项目结构 编写 React 代码 使用 React 渲染一个静态页面 ... 学成网首页 - 静态页面展示 ...另外,虽然字数2w5,但是很大一部分是代码
  • 前文从产业界和学术界分别详细讲解恶意代码攻击溯源的相关知识,在学术界方面,用类似于综述来介绍攻击追踪溯源的不同方法;在产业界方面,主要参考李东宏老师从企业恶意样本分析的角度介绍溯源工作。这篇文章将详细...
  • 向图的基本算法

    千次阅读 2020-12-23 15:36:57
    根据性质,图可以分为无向图和有向图。本文先介绍无向图,后文再介绍有向图。之所以要研究图,是因为图在生活中应用比较广泛。无向图图是若干个顶点(Vertices)和边(Edges)相互连接组成的。边仅由两个顶点连接,并且...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 335,008
精华内容 134,003
关键字:

有向图代码的实现步骤