唐唐爱吃糖糖

数据结构与算法（四）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nTEl1AUE-1686205207094)(https://s2.loli.net/2022/08/18/sMHy2Ga3bqwuDBY.png)]

图结构篇

图结构在我们的生活中实际上是非常常见的，其中最显著的就是我们的地图了，比如我的家乡重庆：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5hyt35Zr-1686205207096)(https://s2.loli.net/2022/09/04/HFR6kX18NnjGx94.png)]

可以看到，地图盘根错节，错综复杂，不同的道路相互连接，我们可以自由地从这些道路通过，从一个地点到达另一个地点。当然除了地图，我们的计算机网络、你的人际关系网等等，这些都可以用图结构来表示。图结构也是整个数据结构中比较难的一部分，而这一章，我们将探讨图结构的性质与应用。

图也是由多个结点连接而成的，但是一个结点可以同时连接多个其他结点，多个结点也可以同时指向一个结点，跟我们之前讲解的树结构不同，它是一种多对多的关系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bBkHJCe7-1686205207097)(https://s2.loli.net/2022/08/21/zGfXODMAVc7aH34.png)]

它比树形结构更加复杂，没有明确的层次关系，结点与结点之间的连接关系更加自由，图结构是任意两个数据对象之间都有可能存在某种特定关系的数据结构。

基本概念

图（Graph）一般由两个集合共同构成，一个是非空但是有限的顶点集合V（Vertex），另一个是描述顶点之间连接关系的边集合E（Edge，边集合可以为空集，比如只有一个顶点的情况下，没得连啊），一个图实际上正是由这些结点（顶点）和对应的边组成的。因此，图可以表示为： $G = (V, E)$

比如一个图我们可以表示为，集合 $V = \{A,B,C,D\}$ ，集合 $E = \{(A,B),(B,C),(C,D),(D,A),(C,A)\}$ ，图有两种基本形式，一种是上面那样的有向图（有向图表明了方向，从哪个点到哪个点），还有一种是无向图（无向图仅仅是连接，并不指明方向），比如我们上面这样表示就是一个无向图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dvq2pGHA-1686205207098)(https://s2.loli.net/2022/08/22/nqjEmh5YyJlkFZQ.png)]

每个结点的度就是与其连接的边数，每条边是可以包含权值的，当前也可以不包含。

当然我们也可以将其表示为有向图，集合 $V = \{A,B,C,D\}$ ，集合 $\{,,,,\}$ 注意有向图的边使用尖括号<>表示。比如上面这个有向图，那么就长这样：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nc5y3rG1-1686205207099)(https://s2.loli.net/2022/08/22/V9BuJt72QH5SEb3.png)]

如果是无向图的一条边(A,B)，那么就称A、B互为邻接点；如果是有向图的一条边，那么就称起点A邻接到终点B。有向图的每个结点分为入度和出度，其中入度就是与顶点相连且指向该顶点的边的个数，出度就是从该顶点指向邻接顶点的边的个数。

只要我们的图中不出现自回路边或是重边，那么我们就可以称这个图为简单图，比如上面两张图都是简单图。而下面的则是典型的非简单图了，其中图一出现了自回路，而图二出现了重边：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MzXuyCB9-1686205207100)(https://s2.loli.net/2022/08/22/JSr2lIKfZ7X9OeR.png)]

如果在一个无向图中，任意两个顶点都有一条边相连，则称该图为无向完全图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMrCCGez-1686205207101)(https://s2.loli.net/2022/08/22/G6tJfjZpaNsx5gE.png)]

同样的，在一个有向图中，如果任意两顶点之间都有由方向互为相反的两条边连接，则称该图为有向完全图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qve6MJ4u-1686205207102)(https://s2.loli.net/2022/08/22/obs24zGhCKmS6Fu.png)]

图通过边将顶点相连，这样我们就可以从一个顶点经过某条路径到达其他顶点了，比如我们现在想要从下面的V5点到达V1点：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JIgf134I-1686205207102)(https://s2.loli.net/2022/08/22/1hTPvxCscLg2SKy.png)]

那么我们可以有很多种路线，比如经过V2到达，经过V3到达等：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FpE3TpWi-1686205207103)(https://s2.loli.net/2022/08/22/dsMRoAJiBxVCTju.png)]

在一个无向图中，如果从一个顶点到另一个顶点有路径，那么就称这两个顶点是连通的。可以看到，要从V5到达V1我们可以有很多种选择，从V5可以到达V1（当然也可以反着来），所以，我们称V5和V1连通的。特别的，如果图中任意两点都是连通的，那么我们就称这个图为连通图。对于有向图，如果图中任意顶点A和B，既有从A到B的路径，也有B到A的路径，则称该有向图是强连通图。

对于图 $G = (V, E)$ 和 $G^{'} = (V^{'}, E^{'})$ ，若满足 $V^{'}$ 是 $V$ 的子集，并且 $E^{'}$ 是 $E$ 的子集，则称 $G^{'}$ 是 $G$ 的子图，比如下面的两个图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zkvXppA2-1686205207104)(https://s2.loli.net/2022/08/22/5hLlIVNf1o4BRuM.png)]

其中右边的图就满足上述性质，所以说右边的图是左边图的子图。

无向图的极大连通子图称为连通分量，有向图的极大连通子图称为强连通分量。那么什么是极大连通子图呢？首先连通子图就是原图的子图，并且子图也是连通图，同时应该具有最大的顶点数，即再加入原图中的其他顶点会导致子图不连通，拥有极大顶点数的同时也要包含依附于这点顶点所有的边才行，比如：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EMPfEloY-1686205207104)(https://s2.loli.net/2022/08/22/jlUfrcTXNPYGvOR.png)]

可以看到右侧图1、2、3都是左图的子图，但是它们并不都是原图的连通分量，首先我们来看图1，它也是一个连通图，并且包含极大顶点数和所有的边（也就是原图内部的这一块）所以说它是连通分量，我们接着来看图2，它虽然也是连通图，但是并没有包含极大顶点数（最多可以吧D也给加上，但是这里没加）所以说并不是。最后来看图3，它也是连通图，并且包含了极大顶点数和边，所以说是连通分量。

原图为连通图，那么连通分量就是其本身，有且仅有一个。
原图为非连通图，那么连通分量会有多个。

对于极小连通子图，我们会在后面的生成树部分进行讲解。

存储结构

前面我们介绍了图的一些基本概念，我们接着来看如何在程序中对图结构进行表示，这一部分可能会涉及到某些在《线性代数》这门课程中出现的概念。

邻接矩阵

邻接矩阵实际上就是用矩阵去表示图中各顶点之间的邻接关系和权值。假设有一个图 $G = (V, E)$ ，其中有N个顶点，那么我们就可以使用一个N×N的矩阵来表示，比如下面有A、B、C、D四个顶点的图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pLGXiGiu-1686205207105)(https://s2.loli.net/2022/08/22/V9BuJt72QH5SEb3.png)]

此时我们需要使用邻接矩阵来表示它，就像下面这样：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QCXJkwmC-1686205207106)(https://s2.loli.net/2022/08/22/PjTo236CahYf1DZ.png)]

对于一个不带权值的图来说：
$G_{ij} = \begin{cases} 1, 无向图的(v_i,v_j)或有向图的是图中的边\\ 0, 无向图的(v_i,v_j)或有向图的不是图中的边 \end{cases}$
对于一个带权值的图来说，如果有边，则直接填写对应边的权值，如果没有，那么就填写0或是∞（因为某些图会认为0也是权值，所以说可以用∞，它可以是一个计算机允许的最大值大于所有边的权值的数）来进行表示：
$G_{ij} = \begin{cases} w_{ij}, 无向图的(v_i,v_j)或有向图的是图中的边\\ 0或∞, 无向图的(v_i,v_j)或有向图的不是图中的边 \end{cases}$
所以说，对于上面的有向图，我们应该像这样填写：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eb3QnwhA-1686205207106)(https://s2.loli.net/2022/08/22/AzuomNgXr78TFDp.png)]

那么我们来看看无向图的邻接矩阵呢？比如下面的这个图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qtKEFp4C-1686205207107)(https://s2.loli.net/2022/08/22/nqjEmh5YyJlkFZQ.png)]

对于无向图来说，一条边两边是相互连接的，所以说，A连接B，那么B也连接A，所以说就像这样：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ckyJDQmT-1686205207108)(/Users/nagocoler/Library/Application Support/typora-user-images/image-20220822222331925.png)]

可以看到得到的矩阵用我们在《线性代数》中的定义来说就是一个对称矩阵（上半和下半都是一样的）因为没有自回路顶点，所以说主对角线上的元素全都是0。由于无向图没有方向之分，顶点之间是相互连接的，所以说无向图的邻接矩阵必定是一个对称矩阵。

我们可以来总结一下性质：

无向图的邻接矩阵一定是一个对称矩阵，因此，有时为了节省时间，我们可以只存放上半部分。
对于无向图，邻接矩阵的第i行非0（或非∞）的个数就是第i个顶点的度。
对于有向图，邻接矩阵的第i行非0（或非∞）的个数就是第i个顶点的出度（纵向就是入度了）

接着我们来看看如何通过代码实现，首先我们需要对结构体进行一下定义，这里我们以有向图为例：

#define MaxVertex 5

typedef char E;   //顶点存放的数据类型，这个不用我多说了吧

typedef struct MatrixGraph {
    int vertexCount;   //顶点数
    int edgeCount;     //边数
    int matrix[MaxVertex][MaxVertex];   //邻接矩阵
    E data[MaxVertex];    //各个顶点对应的数据
} * Graph;

接着我们可以对其进行一下初始化创建后返回：

Graph create(){   //创建时，我们可以指定图中初始有多少个结点
    Graph graph = malloc(sizeof(struct MatrixGraph));
    graph->vertexCount = 0;    //顶点和边数肯定一开始是0
    graph->edgeCount = 0;
    for (int i = 0; i < MaxVertex; ++i)    //记得把矩阵每个位置都置为0
        for (int j = 0; j < MaxVertex; ++j)
            graph->matrix[i][j] = 0;
    return graph;
}

int main(){
    Graph graph = create();   //这里咱们就搞一个
    
}

接着我们就可以编写一下添加顶点和添加边的函数了：

void addVertex(Graph graph, E element){
    if(graph->vertexCount >= MaxVertex) return;
    graph->data[graph->vertexCount++] = element;   //添加新元素
}

void addEdge(Graph graph, int a, int b){   //添加几号顶点到几号顶点的边
    if(graph->matrix[a][b] == 0) {
        graph->matrix[a][b] = 1;  //注意如果是无向图的话，需要[a][b]和[b][a]都置为1
        graph->edgeCount++;
    }
}

我们来尝试构建一下这个有向图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U8SvAsiv-1686205207109)(https://s2.loli.net/2022/08/22/V9BuJt72QH5SEb3.png)]

Graph graph = create();
for (int c = 'A'; c <= 'D' ; ++c) 
    addVertex(graph, (char) c);
addEdge(graph, 0, 1);   //A -> B
addEdge(graph, 1, 2);   //B -> C
addEdge(graph, 2, 3);   //C -> D
addEdge(graph, 3, 0);   //D -> A
addEdge(graph, 2, 0);   //C -> A

接着我们打印此领接矩阵，看看是否变成了我们预想中的那样：

void printGraph(Graph graph){
    for (int i = -1; i < graph->vertexCount; ++i) {
        for (int j = -1; j < graph->vertexCount; ++j) {
            if(j == -1)
                printf("%c", 'A' + i);
            else if(i == -1)
                printf("%3c", 'A' + j);
            else
                printf("%3d", graph->matrix[i][j]);
        }
        putchar('\n');
    }
}

最后得到：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HSd63lGk-1686205207110)(https://s2.loli.net/2022/08/30/1XnqfOBEHd4DPTk.png)]

可以看到结果跟我们上面推导得出的邻接矩阵一模一样，当然这里仅仅是演示了普通的有向图，我们也可以稍微将代码进行修改，将其变成一个无向图或是带权有向图，这里就不做演示了。

邻接表

前面我们介绍了领接矩阵，我们可以使用邻接矩阵在程序中保存一个图的边相关信息，它采用二维数组的形式，将对应边的连接关系进行存储，但是我们知道，数组存在容量上的局限性（学了这么多节课了，应该能体会到，数组需要一段连续空间，无论是申请还是用起来都很麻烦）同时，我们创建邻接矩阵后，如果图的边数较多（稠密图）利用率还是挺高的，但是一旦遇到边数很少的图（稀疏图）那么表中大量的位置实际上都是0，根本没有被利用起来，是很浪费的。

此时，我们可以考虑使用链式结构来解决这种问题，就像下面这样：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IwC89VcY-1686205207111)(https://s2.loli.net/2022/08/30/2H68yAbFS9GnKD4.png)]

对于图中的每个顶点，建立一个数组，存放一个头结点，我们将与其邻接的顶点，通过一个链表进行记录（看着挺像前面讲的哈希表）这样，也可以表示一个图的连接关系，并且内存空间能够得到更加有效的利用。当然，对于无向图来说，跟之前一样，两边都需要进行保存：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z5OaTckZ-1686205207111)(https://s2.loli.net/2022/08/30/vJ65hqwpuzRLs1O.png)]

我们来尝试编写一下代码实现，首先还是定义：

#define MaxVertex 5

typedef char E;

typedef struct Node {   //结点和头结点分开定义，普通结点记录邻接顶点信息
    int nextVertex;
    struct Node * next;
} * Node;

struct HeadNode {   //头结点记录元素
    E element;
    struct Node * next;
};

typedef struct AdjacencyGraph {
    int vertexCount;   //顶点数
    int edgeCount;     //边数
    struct HeadNode vertex[MaxVertex];
} * Graph;

接着是对其进行初始化：

Graph create(){   //创建时，我们可以指定图中初始有多少个结点
    Graph graph = malloc(sizeof(struct AdjacencyGraph));
    graph->vertexCount = graph->edgeCount = 0;
    return graph;   //头结点数组一开始可以不用管
}

在添加边和顶点时，稍微麻烦一些：

void addVertex(Graph graph, E element){
    if(graph->vertexCount >= MaxVertex) return;   //跟之前一样
    graph->vertex[graph->vertexCount].element = element;   //添加新结点时，再来修改也行
    graph->vertex[graph->vertexCount].next = NULL;
  	graph->vertexCount++;
}

void addEdge(Graph graph, int a, int b){
    Node node = graph->vertex[a].next;
    Node newNode = malloc(sizeof(struct Node));
    newNode->next = NULL;
    newNode->nextVertex = b;
    if(!node) {    //如果头结点下一个都没有，那么直接连上去
        graph->vertex[a].next = newNode;
    } else {   //否则说明当前顶点已经连接了至少一个其他顶点了，有可能会出现已经连接过的情况，所以说要特别处理一下
        do {
            if(node->nextVertex == b) return;   //如果已经连接了对应的顶点，那么直接返回
            if(node->next) node = node->next;   //否则继续向后遍历
            else break;   //如果没有下一个了，那就找到最后一个结点了，直接结束
        } while (1);
        node->next = newNode;
    }
  	graph->edgeCount++;   //边数计数+1
}

我们来将其构建一下吧，还是以上面的图为例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AwhRUlPV-1686205207112)(https://s2.loli.net/2022/08/22/V9BuJt72QH5SEb3.png)]

int main(){
    Graph graph = create();
    for (int c = 'A'; c <= 'D' ; ++c)
        addVertex(graph, (char) c);
    addEdge(graph, 0, 1);   //A -> B
    addEdge(graph, 1, 2);   //B -> C
    addEdge(graph, 2, 3);   //C -> D
    addEdge(graph, 3, 0);   //D -> A
    addEdge(graph, 2, 0);   //C -> A

    printGraph(graph);
}

我们来打印看看效果：

void printGraph(Graph graph){
    for (int i = 0; i < graph->vertexCount; ++i) {
        printf("%d | %c", i, graph->vertex[i].element);
        Node node = graph->vertex[i].next;
        while (node) {
            printf(" -> %d", node->nextVertex);
            node = node->next;
        }
        putchar('\n');
    }
}

得到结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0dxVUmrn-1686205207112)(https://s2.loli.net/2022/08/30/Colcf6k7hpIGTDt.png)]

可以看到结果符合我们的预期。

不过虽然这样的方式看上去更加的简单高效，但是会给我们带来一些不必要的麻烦，比如上面创建的领接表，我们只能快速得到某个顶点指向了哪些顶点，也就是只能计算到顶点的出度，但是无法快速计算顶点的入度，只能将所有结点统计之后才能得到入度。所以说在表示有向图时，查找上并没有邻接矩阵来的方便。

为了解决这种问题，我们可以建立一个逆领接表，来表示所有指向当前顶点的顶点列表：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F9zvEb2i-1686205207113)(https://s2.loli.net/2022/08/30/YlAgIUmGdP2Ej3X.png)]

实际上就是反着来而已，通过建立这两个领接表，就能在一定程度上缓解不方便的情况。

图练习题：

在一个具有n个顶点的有向图中，若所有顶点的出度之和为s，则所有顶点的入度数之和为？

A. s B. s - 1 C. s + 1 D. 2s

有向图的所有出度实际上就是所有顶点连向其他顶点的边数，对于单个顶点来说，要么是自己指向别人（自己的出度，别人的入度），要么别人指向自己（别人的出度，自己的入度），这东西就是个相对的而已，而这些都可以一律看做出度，所以说所有顶点入度数之和就是所有顶点出度之和，所以选A
在一个具有n个顶点的无向完全图中，所含的边数为？

A. n B. n(n-1) C. n(n - 1)/2 D. n(n + 1)/2

首先回顾一下无向完全图的定义：在一个无向图中，任意两个顶点都有一条边相连，则称该图为无向完全图。既然任意两个顶点都有一个，那么每个结点都会有n-1条与其连接的边，所以说总数为 $\times (n-1)$ 但是由于是无向图，没有方向之分，所以说需要去掉一半的数量，得到 $\frac {n \times (n-1)} {2}$ ，选择C
若要把n个顶点连接为一个连通图，则至少需要几条边？

A. n B. n - 1 C. n + 1 D. 2n

连通图的定义是，每个顶点至少有一条到达其他顶点的路径，所以说我们只需要找一个最简单能够保证每个结点都有与其相连的就行了，也就是连成一根直线（或者是树）的情况，选择B
对于一个具有 n 个顶点和 e 条边的无向图，在其对应的邻接表中，所含边结点有多少个？

A. n B. ne C. e D. 2e

对于无向图，这结点个数等于边数的两倍，对于有向图，刚好等于边数，所以说选择 D

图的遍历

记得小时候每次去书店，都能看到迷宫书：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZtM9ZFZ-1686205207113)(https://s2.loli.net/2022/08/31/NR1W9HQVnI5rZj8.png)]

每次看到都想买一本，但是当时家里条件并不允许消费这么贵的书，所以都只能在书店多看几眼再回去。迷宫的解，实际上就是我们在一个复杂的地图中寻找一条能够从起点到达终点的路径。可以看到从起点开始，每到一个路口，可能都会出现多个分叉，可能有的分叉就会走进死胡同，有的分叉就会走到下一个路口。

那么我们人脑是怎么去寻找到正确的路径呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6r8WooKV-1686205207114)(https://s2.loli.net/2022/08/31/t7RFJSnBdu2pxcL.png)]

我们首先还是会从起点开始看，我们会尝试去走分叉路的每一个方向，如果遇到死胡同，那么我们就退回到上一个路口，再去尝试其他方向，直到能一直往下走为止。经过不断重复上述的操作，最后我们就肯定能够到达迷宫的出口了。

而图的搜索，实际上也是类似于迷宫这样的形式，我们需要从图的某一个顶点出发，去寻找到图中对应顶点的位置，这一部分，我们将对图的搜索算法进行讨论。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5HzfH6PI-1686205207115)(https://s2.loli.net/2022/08/31/WYxKZwDMtej1JXv.png)]

深度优先搜索（DFS）

我们之前在学习二叉树的过程中，讲解了树的前序遍历，各位回想一下，我们当时是如何在进行遍历的？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WXXG9ww9-1686205207115)(https://s2.loli.net/2022/08/14/ZRjFywa6kWHrbJY.png)]

前序遍历就是勇往直前，直接走到底，然后再回去走其他的分支，而我们的图其实也可以像这样，我们可以一路向前，如果到了死胡同，那么就倒回去再走其他的方向，如果所有方向都走不通，继续再回到上一个路口（实际上就是我们人脑的思维）这样不断的寻找，肯定是可以找到的。

比如现在我们要从A开始寻找下图中的I：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3gyQE6Qc-1686205207116)(https://s2.loli.net/2022/08/31/XgN2k3Ce9VnUDaR.png)]

那么我们的路线可以是这样的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VlMNwyM5-1686205207116)(https://s2.loli.net/2022/08/31/XO93w5N6tEMIhFZ.png)]

此时顶点B有三个方向，那么我们可以先随便选一个方向（当然，一般情况下为了规范，推荐按照字母排列顺序来走，这里为了演示，就随便走了）看看：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BL71AqoG-1686205207116)(https://s2.loli.net/2022/08/31/gFIJDkKEOe4bzl5.png)]

此时来到K，我们发现K已经是一个死胡同，没有其他路了，那么此时我们就需要回到上一个路口，继续去探索其他的路径：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zyAhRrBu-1686205207117)(https://s2.loli.net/2022/08/31/NSUDtQTRZfoBnuY.png)]

此时我们接着往下一个相邻的顶点G走，发现G有其他的分叉，那么我们就继续向前：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JZOGUXP1-1686205207117)(https://s2.loli.net/2022/08/31/sp39cE8yhT54F1R.png)]

此时走到F发现又是死路，那么退回到G，走其他的方向：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IGl2yb8e-1686205207118)(https://s2.loli.net/2022/08/31/a8I7smtX6PK3NVe.png)]

运气太垃了，又到死胡同了，同样的，回到G继续走其他方向：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ktrqtAGW-1686205207118)(https://s2.loli.net/2022/08/31/o8MSFfkiHe1ptGV.png)]

走到C之后，我们有其他的路，我们继续往后走：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kv4tZOTp-1686205207119)(https://s2.loli.net/2022/08/31/v4rlfJdkaWCIcOi.png)]

此时走到顶点H，发现H只有一条路，并且H再向前是已经走过的顶点B，那么此时不能再向前了，所以说直接退回到C，走另一边：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FsjRKVg7-1686205207119)(https://s2.loli.net/2022/08/31/JCNUjlfpOgbkLIQ.png)]

此时来到E，又有两条路，那么继续随便选一条走：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ITIcCNUs-1686205207121)(https://s2.loli.net/2022/08/31/IK1AZgGjXr3LqJm.png)]

此时来到顶点J，发现又是死胡同，退回到E，继续走另一边：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p66hMWmq-1686205207121)(https://s2.loli.net/2022/08/31/3PfzdGYI6Dv745x.png)]

好了，经过了这么多试错，终于是找到了I顶点，这种方式就是深度优先搜索了。

那么我们就来打个代码玩玩吧，这里我们构建一个简单一点的图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LJ1zOG1y-1686205207122)(https://s2.loli.net/2022/08/31/m7lHM3zQvoRs8Uw.png)]

这里我们使用邻接表表示图，因为邻接表直接保存相邻顶点，所以说到达顶点时遍历相邻顶点会更快（能够到达 $O (V + E)$ 线性阶）而如果使用邻接矩阵的话，我们得完整遍历整个二维数组，就比较费时间了（需要 $O(V^2)$ 平方阶）。

比如现在我们想从A开始查找顶点F，首先先把图给建好（注意有6个顶点，记得容量写好）：

int main(){
    Graph graph = create();
    for (int c = 'A'; c <= 'F' ; ++c)
        addVertex(graph, (char) c);
    addEdge(graph, 0, 1);   //A -> B
    addEdge(graph, 1, 2);   //B -> C
    addEdge(graph, 1, 3);   //B -> D
    addEdge(graph, 1, 4);   //D -> E
    addEdge(graph, 4, 5);   //E -> F

    printGraph(graph);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6RhRNGEN-1686205207123)(https://s2.loli.net/2022/08/31/gS3uycojfd4GBDT.png)]

然后就是我们的深度优先搜索算法了：

/**
 * 深度优先搜索算法
 * @param graph 图
 * @param startVertex 起点顶点下标
 * @param targetVertex 目标顶点下标
 * @param visited 已到达过的顶点数组
 */
void dfs(Graph graph, int startVertex, int targetVertex, int * visited){

}

我们先将深度优先遍历写出来：

/**
 * 深度优先搜索算法（无向图和有向图都适用）
 * @param graph 图
 * @param startVertex 起点顶点下标
 * @param targetVertex 目标顶点下标
 * @param visited 已到达过的顶点数组
 */
void dfs(Graph graph, int startVertex, int targetVertex, int * visited) {
    visited[startVertex] = 1;   //走过之后一定记得mark一下
    printf("%c -> ", graph->vertex[startVertex].element);   //打印当前顶点值
    Node node = graph->vertex[startVertex].next;   //遍历当前顶点所有的分支
    while (node) {
        if(!visited[node->nextVertex])   //如果已经到过（有可能是走其他分支到过，或是回头路）那就不继续了
            dfs(graph, node->nextVertex, targetVertex, visited);  //没到过就继续往下走，这里将startVertex设定为对于分支的下一个顶点，按照同样的方式去寻找
        node = node->next;
    }
}

int main(){
    ...

    int arr[graph->vertexCount];
    for (int i = 0; i < graph->vertexCount; ++i) arr[i] = 0;
    dfs(graph, 0, 5, arr);
}

深度优先遍历结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mOkoxO5A-1686205207124)(https://s2.loli.net/2022/08/31/TNwzR2d5ZGt7Sau.png)]

路线如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iSIB1PA8-1686205207124)(https://s2.loli.net/2022/08/31/RZE9zF54cQlYAg8.png)]

现在我们将需要查找的顶点进行判断：

/**
 * 深度优先搜索
 * @param graph 图
 * @param startVertex 起点顶点下标
 * @param targetVertex 目标顶点下标
 * @param visited 已到达过的顶点数组
 * @return 搜索结果，如果找到返回1，没找到返回0
 */
_Bool dfs(Graph graph, int startVertex, int targetVertex, int * visited) {
    visited[startVertex] = 1;
    printf("%c -> ", graph->vertex[startVertex].element);
    if(startVertex == targetVertex) return 1;   //如果当前顶点就是要找的顶点，直接返回
    Node node = graph->vertex[startVertex].next;
    while (node) {
        if(!visited[node->nextVertex])
            if(dfs(graph, node->nextVertex, targetVertex, visited))  //如果查找成功，直接返回1，不用再看其他分支了
                return 1;
        node = node->next;
    }
    return 0;   //while结束那肯定是没找到了，直接返回0
}

int main(){
    ...

    int arr[graph->vertexCount];
    for (int i = 0; i < graph->vertexCount; ++i) arr[i] = 0;
    printf("\n%d", dfs(graph, 0, 5, arr));
}

得到结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b6FXLyum-1686205207125)(https://s2.loli.net/2022/08/31/xAHsYRfzStMwvGT.png)]

再来找一下顶点D呢：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9iTESfos-1686205207125)(https://s2.loli.net/2022/08/31/Gwf1XhDIPT3mUzv.png)]

可以看到到D之后就停止了，因为已经找到了。那么要是去寻找一个没有连接到图中的结点呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-98wWdIwQ-1686205207126)(https://s2.loli.net/2022/08/31/luIONkfmKYPCG2V.png)]

可以看到整个图按照深度优先遍历找完了都没找到。

广度优先搜索（BFS）

前面我们介绍了深度优先搜索，我们接着来看另一种方案。还记得我们在前面二叉树中学习的层序遍历吗？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-639ABhfY-1686205207126)(https://s2.loli.net/2022/08/31/hwiEoZ9OM2Fqv47.png)]

层序遍历实际上是优先将每一层进行遍历，而不是像前序遍历那样勇往直前，而图的搜索其实也可以采用这种方案，我们可以先探索顶点所有的分支，然后再依次去看这些分支的所有分支：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8RWEz2Ag-1686205207127)(https://s2.loli.net/2022/08/31/qm3OUZbv8XzFLiJ.png)]

首先咱还是从A来到B，此时B有三条分叉路，我们依次访问这三条路的各个顶点：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZmcfO14I-1686205207128)(https://s2.loli.net/2022/08/31/SCeXgptNDbdFkLi.png)]

我们先记录一下这三个顶点，同样需要使用队列来完成：H、G、K

注意访问之后不要再继续向下了，接着我们从这三个里面的第一个顶点H开始，按照同样的方法继续：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o9UqT79N-1686205207128)(https://s2.loli.net/2022/08/31/t8c2KVLZM6qx4ui.png)]

此时因为只有一个分支，所以说找到C，继续记录，将C也添加进去：G、K、C

注意此时需要回去，继续看之前三个顶点的第二个顶点G：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NScrlvDH-1686205207129)(https://s2.loli.net/2022/08/31/Y5qFPAbanH4VcuM.png)]

此时C已经看过了，接着就找到了F和D，也是记录一下：K、C、F、D

然后，我们继续看之前三个结点的最后一个：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-baCqQJac-1686205207129)(https://s2.loli.net/2022/08/31/3yfDGmKzLbBhcsA.png)]

此时K已经是死胡同了，那么就结束，然后继续看下一个C：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNMIxwsx-1686205207130)(https://s2.loli.net/2022/08/31/4aTCOYzlm3dLGbt.png)]

此时继续将E给记录进去：F、D、E，接着看D和F，也没有后续了，那么最后就只有E了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sR8Qes0h-1686205207130)(https://s2.loli.net/2022/08/31/lWyvMUbSdsELVNI.png)]

成功找到目标I顶点，实际上广度优先遍历就是尽可能地扩展范围，多去探索广阔的土地，而不是死拽着一根不放，就像爱情，实在得不到就算了吧，她至始至终就没爱过你，不要继续在她身上浪费感情了，多去结交新的朋友，相信你会遇到更好的。

那么按照这个思路，我们就来尝试代码实现一下，首先把队列搬过来：

typedef int T;   //这里将顶点下标作为元素

struct QueueNode {
    T element;
    struct QueueNode * next;
};

typedef struct QueueNode * QNode;

struct Queue{
    QNode front, rear;
};

typedef struct Queue * LinkedQueue;

_Bool initQueue(LinkedQueue queue){
    QNode node = malloc(sizeof(struct QueueNode));
    if(node == NULL) return 0;
    queue->front = queue->rear = node;
    return 1;
}

_Bool offerQueue(LinkedQueue queue, T element){
    QNode node = malloc(sizeof(struct QueueNode));
    if(node == NULL) return 0;
    node->element = element;
    queue->rear->next = node;
    queue->rear = node;
    return 1;
}

_Bool isEmpty(LinkedQueue queue){
    return queue->front == queue->rear;
}

T pollQueue(LinkedQueue queue){
    T e = queue->front->next->element;
    QNode node = queue->front->next;
    queue->front->next = queue->front->next->next;
    if(queue->rear == node) queue->rear = queue->front;
    free(node);
    return e;
}

我们还是以上面的图为例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBA7uxLP-1686205207131)(https://s2.loli.net/2022/08/31/m7lHM3zQvoRs8Uw.png)]

/**
 * 广度优先遍历
 * @param graph 图
 * @param startVertex 起点顶点下标
 * @param targetVertex 目标顶点下标
 * @param visited 已到达过的顶点数组
 * @param queue 辅助队列
 */
void bfs(Graph graph, int startVertex, int targetVertex, int * visited, LinkedQueue queue) {
    offerQueue(queue, startVertex);  //首先把起始位置顶点丢进去
    visited[startVertex] = 1;   //起始位置设置为已走过
    while (!isEmpty(queue)) {
        int next = pollQueue(queue);
        printf("%c -> ", graph->vertex[next].element);  //从队列中取出下一个顶点，打印
        Node node = graph->vertex[next].next;    //同样的，把每一个分支都遍历一下
        while (node) {
            if(!visited[node->nextVertex]) {   //如果没有走过，那么就直接入队
                offerQueue(queue, node->nextVertex);
                visited[node->nextVertex] = 1;   //入队时就需要设定为1了
            }
            node = node->next;
        }
    }
}

我们来测试一下吧：

int main(){
  	...
      
    int arr[graph->vertexCount];
    struct Queue queue;
    initQueue(&queue);
    for (int i = 0; i < graph->vertexCount; ++i) arr[i] = 0;
    bfs(graph, 0, 5, arr, &queue);
}

成功得到结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hCnsjR0s-1686205207132)(https://s2.loli.net/2022/08/31/5Mxt2czgTkoUQ9p.png)]

如果要指定查找的话，就更简单了：

_Bool bfs(Graph graph, int startVertex, int targetVertex, int * visited, LinkedQueue queue) {
    offerQueue(queue, startVertex);
    visited[startVertex] = 1;
    while (!isEmpty(queue)) {
        int next = pollQueue(queue);
        printf("%c -> ", graph->vertex[next].element);
        Node node = graph->vertex[next].next;
        while (node) {
            if(node->nextVertex == targetVertex) return 1;   //如果就是我们要找的，直接返回1
            if(!visited[node->nextVertex]) {
                offerQueue(queue, node->nextVertex);
                visited[node->nextVertex] = 1;
            }
            node = node->next;
        }
    }
    return 0;   //找完了还没有，那就返回0
}

这样，我们就实现了图的广度优先搜索。

图练习题：

若一个图的边集为：{(A, B),(A, C),(B, D),(C, F),(D, E),(D, F)}，对该图进行深度优先搜索，得到的顶点序列可能是：

A. ABCFDE B. ACFDEB C. ABDCFE D. ABDFEC

这种题直接把图画出来，因为边集是圆括号，说是肯定是一个无向图，图先画出来再说：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YYUrjBUa-1686205207132)(https://s2.loli.net/2022/09/02/WZoIyVGu2n3p5hD.png)]

因为这四个选项都是A开始的，所以说我们从A开始看，因为A连接了B和C，所以说A后面紧跟B或是C都可以，接着往下看，先看走B的情况，因为B只连接了一个D，所以说选项A直接排除，接着往下看，D链接了E和F，所以说选项C直接排除，此时只有选项D了，我们接着往后看，此时我们走F，紧接着的只有C，D也不满足，所以选择B（当然你怕不稳的话把B选项也推出来就行了）
若一个图的边集为：{(A, B),(A, C),(B, D),(C, F),(D, E),(D, F)}，对该图进行广度优先搜索，得到的顶点序列可能是：

A. ABCDEF B. ABCFDE C. ABDCEF D. ACBFDE

跟上面是同样的思路，只要各位小伙伴听懂了BFS和DFS的思路，肯定没问题的，选择 D
如下图所示的无向连通图，从顶点A开始对该图进行广度优先遍历，得到的顶点序列可能是：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oBLyxSSP-1686205207133)(https://s2.loli.net/2022/09/02/bKRp6Qzu5vo3fEw.png)]

同样的思路，选择D

图应用

前面我们介绍了图的相关性质，以及图的遍历方式，这一部分我们接着来看图的相关应用。

生成树和最小生成树

在开始讲解最小生成树之前，我们先来回顾一下之前讲解的连通分量。

对于无向图来说，如果图中任意两点都是连通的，那么我们就称这个图为连通图。
对于有向图来说，如果图中任意顶点A和B，既有从A到B的路径，也有B到A的路径，则称该有向图是强连通图。

而连通分量则要求是某个图的子图（子图可以是只包原图含部分顶点和边的图，也可以就是原图本身，因为定义只是子集，不是真子集），并且子图也要是连通的才可以，还有一个重要条件是必须拥有极大顶点数（能够保证图连通的且包含原图最大的顶点数）并且包含所有依附于这些顶点的边（这个极大更偏向于顶点数的极大），我们就称这个子图为极大连通子图。

无向图的极大连通子图称为连通分量。
有向图的极大强连通子图称为强连通分量。

比如下面的有向图，这个图本身并不是连通的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fw3ztyiw-1686205207133)(https://s2.loli.net/2022/09/03/lHEi8GWsIjCFg3D.png)]

其中图1和图2都满足上述条件，都是强连通分量，本身就是连通并且已经到达最大的顶点数和边数了（只要再加入其他的顶点和边就会导致不连通）但是图3并不是子图（A到B的边缺失）并且不是强连通的，所以说不是强连通分量。

又比如下面这个无向图，这个图本身也是不连通的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lBfTZS1b-1686205207134)(https://s2.loli.net/2022/08/22/jlUfrcTXNPYGvOR.png)]

其中图1和图3都满足条件，都是连通分量，但是图2并没有到达最大的顶点数和边数，所以说不是连通分量。

当然上面都是原图不连通的情况，如果原图就是一个连通图，包含其所有顶点和边的子图就已经满足条件了，所以其本身就是一个连通分量；同样的，如果原图就是一个强连通图，那么其本身就是一个强连通分量。

总结如下：

如果原图本身不连通，那么其连通分量（强连通分量）不止一个。
如果原图本身连通，那么其连通分量（强连通分量）就是其本身。

极大连通子图我们回顾完了，那么我们接着来讨论一下极小连通子图。这里的极小主要是说的边数的极小，首先依然要是原图的子图并且是连通的，但是此时要求具有最大的顶点数和最小的边数，也就是说再去掉任意一条边会导致图不连通（直接理解为极大连通子图尽可能去掉能去掉的边就行了）

针对于极小连通子图，我们一般只讨论无向图（对于有向图，不存在极小强连通子图的说法，因为主要是讨论生成树）我们依然将原图就是连通图和原图不是连通图分开分析，首先是原图本身就是连通图的情况：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wg0a7SLV-1686205207134)(https://s2.loli.net/2022/09/01/zCap6w2A51rEnkK.png)]

原图本身就是连通图，那么其极大连通子图就是其本身，此时我们需要尽可能去掉那些“不必要”的边，依然能够保证其是连通的，也就是极小连通子图。可以看到右边两幅图，跟左边这幅图包含了同样的顶点数量，但是边数被去掉了一些，并且如果再继续去掉任意一条边的话，那么就会导致不连通，所以说左边两幅图都是右边这幅图的极小连通图（当然，就像上面这样，可能会出现多种方案，极小连通图不唯一）

我们发现，无论是去掉哪些边的情况，到最后一定是只留下 N-1 条边（其中N是顶点数）每个顶点有且仅有一条路径相连，也就是包含原图全部N个顶点的极小连通子图，我们一般称其为：生成树，为什么叫生成树呢，因为结点数和边数正好满足树的定义（且不存在回路的情况），我们可以将其调整为一棵树：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H1Rih1i4-1686205207135)(https://s2.loli.net/2022/09/03/ldtA9jbE1JXMcWf.png)]

当然，这是原图本身就连通的情况，如果原图本身不连通的话，那么就会出现多个连通分量，此时就会得到一片生成森林，森林中的树的数量就是其连通分量的数量。

那么我们在程序中要怎么才能得到一个有向图的生成树呢？我们可以使用前面讲解的两种图的遍历方式来进行生成，我们以下图为例，这是一个普通的无向连通图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fIPjVFOx-1686205207135)(https://s2.loli.net/2022/09/03/RI5Lrpt8WeOkdZX.png)]

我们如果按照深度优先遍历的方式，从G开始，那么就会得到下面的顺序：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FQnHrZQj-1686205207136)(https://s2.loli.net/2022/09/03/CrsQhon4wxOAjRm.png)]

按照顺序我们就可以得到一棵生成树：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wtYgThbV-1686205207136)(https://s2.loli.net/2022/09/03/k1IctqPrOA6BKgp.png)]

虽然看着很奇怪，但是按照我们的顺序，得到的树就是这样的，可以发现，因为我们的深度优先搜索不会去走那些回头路，相当于直接把哪些导致回路和多余的边给去掉了，最后遍历得到的结果就是一颗生成树了。

同样的，我们来看看如果是按照广度优先遍历的方式，又会得到什么结果呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FsFN2Qh3-1686205207136)(https://s2.loli.net/2022/09/03/UhRBnocjCL3uD9E.png)]

最后得到的生成树为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QA31v99L-1686205207137)(https://s2.loli.net/2022/09/03/FKRSnvProHtXegi.png)]

实际上我们发现，在广度优先遍历下得到的生成树，也是按照每一层在进行排列的，非常清晰。当然，因为深度优先遍历和广度优先遍历本身的顺序就不是唯一的，所以最后得到的生成树也不是唯一的。

生成树讨论完成之后，我们接着来讨论一下最小生成树，那么这个最小指的是什么最小呢？如果我们给一个无向图的边都加上权值（网图）现在要求生成树边的权值总和最小，我们就称这棵树为最小生成树（注意最小生成树不唯一，因为有可能出现多种方案都是最小的情况）比如下面的就是最后得到的最小生成树了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ylme3Lkh-1686205207137)(https://s2.loli.net/2022/09/03/BWEzS1YOwDohRdU.png)]

构建最小生成树有两种算法，一种是**普利姆（Prim）算法，还有一种是克鲁斯卡尔（Kruskal）**算法，我们先来讨论第一种：

我们以下图为例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BOApqC3p-1686205207138)(https://s2.loli.net/2022/09/03/c4Xge3QImBdDKYt.png)]

普利姆算法的核心就是从任意一个顶点开始，不断成长为一棵树，每次都会选择尽可能小的方向去进行延伸，比如我们一开始还是从顶点A开始：

此时与A相连的边有B和E，A的延伸方向有两个，此时我们只需要选择一个最小的就可以了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w6mdFc6J-1686205207138)(https://s2.loli.net/2022/09/03/LZ5ho6mxtweRPMg.png)]

此时我们已经构建出了由A、E组成的一棵树，同样的，我们需要去寻找与当前树中A、E顶点相连的所有顶点，包括B、G、H，哪一个最小，那么下一个延伸的就是哪一个，此时发现H和E之间最小，继续延伸：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yh4HEIEo-1686205207138)(https://s2.loli.net/2022/09/03/zT75jqNVS4RX3bI.png)]

现在已经变成了由A、E、H组成的一棵树，同样的，按照之前的思路继续寻找一个最小的方向进行延伸：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U2VIZv9v-1686205207138)(https://s2.loli.net/2022/09/03/nJWbov1LZNBR8lX.png)]

继续进行延伸，发现F、K之间最小：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yiZJgDwu-1686205207139)(https://s2.loli.net/2022/09/03/OyGRMXi9K5fE3zD.png)]

此时K、B和K、D和K、H的权重都是4，其中H顶点已经走过了，不能出现回路，所以说不考虑，此时随便选择K、B或是K、D都可以，不会影响后续结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3pyqt9xy-1686205207139)(https://s2.loli.net/2022/09/03/uxI21o4vnbdNLkB.png)]

此时依然是K、D为最小，所以说直接选择：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-geFwTxu2-1686205207139)(https://s2.loli.net/2022/09/03/cR2BPhbI5X9jAU3.png)]

紧接着，我们发现最小权重的来到了5，此时权重为5的边有B、E和H、I和B、D，但是由于E、D已经走过，此时直接选择H、I即可：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zNPtO6CI-1686205207140)(https://s2.loli.net/2022/09/03/Lg5Tf1Y2AQ9hjNk.png)]

接着，我们发现I、G也是5，直接选择即可：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DKGor2Gg-1686205207140)(https://s2.loli.net/2022/09/03/sgfxIojGRUYdQHc.png)]

然后最小权重此时就是6了，选择H、J和I、J都可以，随便选择一个即可：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D5srPhzg-1686205207140)(https://s2.loli.net/2022/09/03/T6BoY4IXa3fKpir.png)]

此时，整个图的所有顶点就遍历完成了，现在我们去掉那些没用被采用的边，得到的结果就是我们的最小生成树了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w9bOJeqQ-1686205207141)(https://s2.loli.net/2022/09/03/eVyJ6o8xraRvl3d.png)]

虽然样子有点丑，但是把它捋一捋就好了。可以看到省去的边都是尽可能大的边，或是那种导致回路的边，留下的边基本都是权重小的边，得到的就是最小生成树了（注意考试的时候只要按照我们的思路推是肯定没问题的，但是千万要仔细看，不要把边给看漏了，不然会出大问题）

我们接着来看另一种，克鲁斯卡尔算法，它的核心思想就是我们主动去选择那些小的边，而不是像上面一样被动地扩展延伸。

在一开始的时候，直接去掉所有的边，我们从这些边中一个一个选择出来（注意是任意一条边都可以选择，并不是只有选择的顶点旁边才能选择，这个过程中可能会出现多棵树，但是最后一定会连成一棵树的），最后形成一颗最小生成树，假设一开始什么都没选择，被选中的边我们一会用橙色标注：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hAvppbg4-1686205207141)(https://s2.loli.net/2022/09/03/qdNyC6We2cZHTog.png)]

首先我们直接找到最小边，K、F，它的权值为2，所以说直接选择就行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TwS5PZlS-1686205207141)(https://s2.loli.net/2022/09/03/tTq2NnfJPcvogFG.png)]

紧接着就是F、H的边，权重为3，目前最小的了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YS39mSlN-1686205207142)(https://s2.loli.net/2022/09/03/MtJxvkjZoScT2KH.png)]

此时最小的权重就只有4了，目前有4条边都可以进行选择，但是K、H这条边因为K和H都已经在树中了，所以说不能考虑，其他三条边都是没问题的，我们随便选择一条就行了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rqNq7Xyr-1686205207142)(https://s2.loli.net/2022/09/03/9vEVncqotmeklr7.png)]

继续选择权重为4的边：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E8UeDP6w-1686205207142)(https://s2.loli.net/2022/09/03/BXZjrOTYfow51iD.png)]

此时权重就来到了5，那么权重为5的顶点我们也可以随便选择一条，只要不会导致出现回路就行了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lcIF8NdX-1686205207143)(https://s2.loli.net/2022/09/03/qUd8hiGnYyAZLo5.png)]

此时连接G、I，我们发现出现了两棵树，没关系的，最后会连成一棵树的，我们继续选择其他权重为5的边：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JZClCzmf-1686205207143)(https://s2.loli.net/2022/09/03/hpcVj8HwRJnvaf9.png)]

此时我们选择A、E这条边，然后是H、I这条边，虽然这条边上的H和I顶点都已经在树中了，但是它们并不属于同一棵树，这种情况也是可以连接的，然后我们继续选择权重为6的顶点：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P7u3G39A-1686205207143)(https://s2.loli.net/2022/09/03/Sltei9m4GdHXQkW.png)]

此时选择I、J或是H、J都可以（最小生成树不唯一）现在我们已经连接上所有的顶点了，最小生成树构建完成，我们把那些没有选择都边都扔了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oxIlvA7o-1686205207144)(https://s2.loli.net/2022/09/03/eVyJ6o8xraRvl3d.png)]

其实无论是哪种算法，最后都能够得到一棵最小生成树，有关实现代码，由于太过复杂，这里就不进行编写了。

最短路径问题

前面我们介绍了最小生成树，通过两种算法就能够从众多的边中选择那些尽可能小的边得到一个权重最小的树，这一块我们将继续讨论最小开销相关的问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-23BTSipP-1686205207144)(https://s2.loli.net/2022/09/03/FuxnpoTNezYP9Aa.png)]

地铁线路错综复杂，我们想要从一个站点坐到另一个站点，其实是有很多种方案的，比如我们可以选择少的换乘数放的方案，或是距离近的方案，不同的方案可能坐的站点数就不同，而最后我们出站时，始终是按照从A地点到B地点最小经过的站点数进行收费的（比如从A到B有两种方案，前者要坐11个站，后者要坐7个站，但是最后只会按7个站进行收费），那么这么多线路，我们要如何计算得到一条最短的路径呢？

我们首先从最简单的单源最短路径进行讨论，所谓单源最短路径，就是一个顶点出发，到其他顶点的最短路径，比如下面的这张图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kW1kWtJG-1686205207144)(https://s2.loli.net/2022/09/03/6ABvydlgPUqEYIZ.png)]

要解决这种问题，我们可以采用**迪杰斯特拉（Dijkstra）**算法，下面我们来看看迪杰斯特拉算法是如何让计算机来计算最短路径的，它跟普利姆算法求最小生成树有着很多相似之处，我们就从A出发，这里我们需要一个表来记录：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4UeNvhNm-1686205207144)(https://s2.loli.net/2022/09/03/cU2s1vRGq9SJkpE.png)]

dist这一行记录A到其他顶点的最短路径，path这一行记录的是最短路径所邻接的顶点，我们首先还是从A开始，与A直接相邻的两个分别是B和D，其中B的距离是2，D的距离是5，那么我们就先进行一下记录：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n7KCNDCJ-1686205207145)(https://s2.loli.net/2022/09/03/fxAocwRZFzSYgBb.png)]

因为都是从A过来的，所以说直接记录为A即可，接着我们继续找到当前A路径最短的一个顶点B，此时顶点B可以到达C、D、A，因为不能走回头路，不考虑A，那么目前从A到达C的最短距离就是经过B到达的，相当于A->B加上B->C的距离：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SycMNmca-1686205207145)(https://s2.loli.net/2022/09/03/nbhD6gKrcWHZYwF.png)]

然后我们来看顶点D，此时我们发现，除了A直接到D之外，从B也可以到达D，那么我们就可以比较一下，看是从B到D更短一些，还是从A直接到D更短一些 $min (2 + 2, 5)$ ，通过比较，我们发现从B绕过去会更短一些，只需要4即可，所以说我们将其更新一下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X0TGlCDh-1686205207145)(https://s2.loli.net/2022/09/03/wZtX2eCvWciJ7mo.png)]

接着我们继续找到下一个离A最近的顶点D，D与顶点E和J相连，直接更新即可，比如E的最短路径就是相当于是A到D的最短路径加上D到E的路径，D到J也是同理：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2RfnbeS-1686205207146)(https://s2.loli.net/2022/09/03/RndcpoWkY6Oe84y.png)]

此时继续找到表中下一个距离A最近的顶点J，J可以到达H或者是E，按照同样的方式，我们看看是从D直接到E更短，还是从J到E更短，进行比较 $min (6 + 3, 8)$ ，得到结果是D直接过去更短，所以说不需要更新。然后H更新为J过去的最短路径：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jiqdxIV2-1686205207146)(https://s2.loli.net/2022/09/03/d8qoaxZiymTGBlv.png)]

我们接着来看下一个距离A最近的顶点C，此时C可以到达F和E，我们先来看E，还是对其进行比较，如果从C到达E更短，那么就更新为新的值， $min (7 + 4, 8)$ ，最后仍然是从D到E最短，所以说不变，接着我们把F的值更新一下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BoWX2UZx-1686205207146)(https://s2.loli.net/2022/09/03/uknUSC2gK5adZjL.png)]

然后我们来看下一个距离A最近的顶点E，E连接的就比较多了，此时E最短路径是从D过来的，那么我们就不考虑D，我们来依次看看与其相连的C、F、G、H、J（注意这里比较的是从E到这些顶点，之前比较的是从这些顶点到E，不要以为是一样的了）

从E到达顶点C： $min (8 + 4, 7)$ ，故C继续采用原方案。
从E到达顶点F： $min (8 + 2, 15)$ ，此时从E到达F路径更短，更新F。
从E到达顶点G：直接更新。
从E到达顶点H： $min (8 + 6, 13)$ ，故H继续采用原方案。
从E到达顶点J： $min (8 + 3, 6)$ ，故J继续采用原方案。

最后得到：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-foTkk881-1686205207147)(https://s2.loli.net/2022/09/03/Ek7nhJuXtKSZgeo.png)]

我们继续来到下一个离A最近的顶点F，F连接了G和E，但是由于当前最短路径是从E过来的，不能走回头路，所以说直接去看G，比较 $min (10 + 5, 17)$ ，得到从F到达G会更短，所以说更新G：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nsVGycyH-1686205207147)(https://s2.loli.net/2022/09/03/mphBFRsLArDQHwK.png)]

然后我们接着看到下一个最短的顶点H，此时H与G和I相连，我们先来看G， $min (13 + 3, 15)$ ，维持原方案。然后是I，直接更新即可：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hm0ijjcw-1686205207148)(https://s2.loli.net/2022/09/03/PlHs4NE8JTiFZad.png)]

虽然此时表已经填完了，但是我们还没有把所有的顶点都遍历完，有可能还会存在更短的路径，所以说别着急，我们还得继续看。此时继续选择下一个离A最近的顶点G，它与E、F、H、I相连，由于其实从F过来的，排除掉F，我们来看看其他三个：

从G到达顶点E： $min (15 + 9, 8)$ ，显然选择原方案就行。
从G到达顶点H： $min (15 + 3, 13)$ ，依然是选择原方案更短。
从G到达顶点I： $min (15 + 4, 21)$ ，从G到达I更短，更新。

最后得到：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sbksicek-1686205207148)(https://s2.loli.net/2022/09/03/RL9XeTnAJBdUNMF.png)]

此时我们来看最后一个顶点I，与其连接的有G和H，因为是从G过来的，直接比较H就行了， $min (19 + 8, 13)$ ，维持原方案就行，至此，迪杰斯特拉算法结束。最后得到的表，就是最终的A到达各个顶点的最短路径值了，并且根据path这一栏的数据，我们就可以直接推出一条路径出来。

当然，这只是解决了单源最短路径问题，现在我们将问题的难度提升一下，比如我们现在想要求得图中每一对顶点之间的最短路径，那么该如何进行计算呢？最简单的办法就是，我们可以将所有的顶点都执行一次迪杰斯特拉算法，这样我们就可以求到所有顶点之间的最短距离了。只不过这种方式并不是最好的选择，对于这种问题，我们可以选择弗洛伊德（Floyd）算法。

比如下面的有向网图（权值别出现负数了，不然要出大问题）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mbRxm2Y8-1686205207148)(https://s2.loli.net/2022/09/04/MdPc7Ew96Ukzxjt.png)]

我们可以很轻松地得到它的邻接矩阵：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0EG9kaYy-1686205207148)(https://s2.loli.net/2022/09/04/ZQ7KvWeuJ6bdThx.png)]

而弗洛伊德算法则是根据最初的邻接矩阵进行推导得出的。规则如下：

从1开始，一直到n（n就是顶点数）的一个矩阵序列A1、A2、…An，我们需要从最初的邻接矩阵开始，从A1开始不断往后推。
每一轮，我们都会去更新那些非对角线（对角线都是0，更新了还是0，所以说没必要看）、i行i列以外的元素，判断水平和垂直方向投影的两个元素之和是否比原值小，如果是，那就更新为新的值。迭代公式为： $A_k(i,j)=min(A_{k−1}(i,j), A_{k−1}(i,k)+A_{k−1}(k,j))$
经历n轮后，最后得到的就是最终的最短距离了。

我们从第一轮开始，第一轮是基于原有的邻接矩阵来进行处理的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xVL6VPqO-1686205207149)(https://s2.loli.net/2022/09/04/czu5FEq8gGsRC97.png)]

此时我们看到，除了对角线以外，就是B->C和C->B的这两个位置，我们按照上面的规则，进行计算：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N8JgLe5X-1686205207149)(https://s2.loli.net/2022/09/04/i3csRCQaxW17jV9.png)]

同样的，我们继续看到C->B这个为止，按照同样的方式进行更新：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hv9Kecrs-1686205207149)(https://s2.loli.net/2022/09/04/TsIgShcqrdR3BaQ.png)]

最后更新完成得到的结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j7dtxSEW-1686205207150)(https://s2.loli.net/2022/09/04/dObC8f2u6SqX4eT.png)]

实际上我们发现，我们计算的和相当于是绕路的结果与当前直接走的结果相比较得到的。按照的同样的方式，我们开始第二轮：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yVvoYbPV-1686205207150)(https://s2.loli.net/2022/09/04/tXkEVLqR5dIchWT.png)]

更新完成之后，C->A的距离变成了5：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-89TwEhNZ-1686205207150)(https://s2.loli.net/2022/09/04/b9SGVFR6xEWBtgp.png)]

我们接着来看最后一轮：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dSN5imO0-1686205207151)(https://s2.loli.net/2022/09/04/alRYcGDp8xETLn1.png)]

此时我们将A->B的距离也更新一下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DwbeFaHP-1686205207151)(https://s2.loli.net/2022/09/04/Qwa2JMLXYBhnFsd.png)]

最后我们得到的矩阵，存放的就是所有顶点之间的最短距离了，当然这里我们只计算了最短距离，没有去记录从哪个方向到达此顶点的，各位小伙伴也可以在计算的同时单独在另一个表中记录一下从哪个顶点过去计算出来的最小距离，这里就不演示了。实际上这个算法对我们来说是更好理解的一种算法，并且在编写程序时也会很简单，我们以下图为例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UehFIVZ1-1686205207151)(https://s2.loli.net/2022/09/04/9fuBUwRYav4bghd.png)]

代码如下：

#define INF 210000000
#define N 4

int min(int a, int b){
    return a > b ? b : a;
}

void floyd(int matrix[N][N], int n){
    for (int k = 0; k < n; ++k)    //一共需要执行K轮
        for (int i = 0; i < n; ++i)   //i和j从0开始就行了，直接全看，不会影响结果的
            for (int j = 0; j < n; ++j)
                matrix[i][j] = min(matrix[i][k] + matrix[k][j], matrix[i][j]);   //按照规则更新就行了
}

int main(){
    int matrix[N][N] = {{0, 1, INF, INF},
                        {4, 0, INF, 5},
                        {INF, 2, 0, INF},
                        {3, INF, 7, 0}};

    floyd(matrix, N);

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j)
            printf("%d ", matrix[i][j]);
        putchar('\n');
    }
}

最后得到的结果为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pF4Dj4Uv-1686205207152)(https://s2.loli.net/2022/09/04/mDWY8ZzqSipRGFa.png)]

经过对比，确实是最短的路径了。

拓扑排序

我们接着来看拓扑排序，实际上我们生活中可能会遇到下面的问题：

比如我们的大学课程的学习，一些课程开启可能需要修完一些前置课程，比如数据结构开课需要先修完C语言程序设计，Java开课需要修完计算机网络、计算机组成原理等课程，我们在到达某个阶段之前，需要完成一些前置条件才可以解锁。包括我们游戏中的任务，需要先完成哪些主线任务，完成哪些支线任务，才能解锁新的阶段。

我们可以将这些任务都看做是一个顶点，最后就能够连接成一个有向图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jrpwsVSt-1686205207152)(https://s2.loli.net/2022/09/04/OoPBQgd9WrSJhNx.png)]

因为始终是由前置条件来解锁后续，所以说整个图中是不可以出现循环的（要是有循环的话就没办法继续了，就像先有鸡还是先有蛋的问题一样）所以说构建出来的这种图我们也称为有向无环图（DAG），其实按照我们通俗的话来说，它就是个流程图罢了，我们只需要按照这个流程图来进行即可。像这种顶点表示活动或任务的图也称为AOV图。

拓扑排序（Topological Order）是指，将一个有向无环图（Directed Acyclic Graph）进行排序进而得到一个有序的线性序列。

比如上图的拓扑排序可以是以下的几种：

A,B,C,D,E,F,G,H,I,J
A,C,D,B,E,F,G,H,I,J
A,D,C,B,E,F,G,H,I,J
A,B,D,C,E,F,G,H,I,J

只要我们保证前置任务在后续任务之前完成即可，前置任务的完成顺序不做要求，所以拓扑排序不唯一。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xKtOoe0o-1686205207153)(https://s2.loli.net/2022/09/04/uMWBeLlzh9vHpdC.png)]

那么我们在程序中如何对一个有向无环图进行拓扑排序呢？以上图为例，其实很简单，我们还是利用队列来完成，我们每次只需要将那些入度为0的顶点，丢进队列中（注意丢进去之后记得更新一下图中其他顶点的入度）首先从A：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1O8Ayp5I-1686205207153)(https://s2.loli.net/2022/09/04/7bRdsEGLMqokZCf.png)]

此时队列中有A这个顶点，接着我们来看看图中剩余的顶点，哪些又是入度为0的顶点，可以看到D也是：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OCDHu40E-1686205207154)(https://s2.loli.net/2022/09/04/quj1yedrT69OQz3.png)]

当目前所有度数为0的顶点进入队列之后，我们开始出队，正式开始拓扑排序，在出队时直接打印，并且查看，当此顶点离开图之后，图中会不会有其他顶点的入度变为0，如果有，将其他顶点入队。比如此时A出队之后，那么A要从图中移除，现在B也变成了入度为0的顶点，所以说将B丢进队列：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a1TI4lWJ-1686205207154)(https://s2.loli.net/2022/09/04/23gdNArusypQS84.png)]

接着，我们继续让D出队，我们发现D出队之后，E变成了入度为0的顶点，所以说将E入队：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SIO2TDJd-1686205207154)(https://s2.loli.net/2022/09/04/wjZ4TFslOL69IBA.png)]

接着我们继续出队，B出队之后，我们发现没有任何顶点入度变为0了，所以说不管，继续：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-65wrxXjo-1686205207155)(https://s2.loli.net/2022/09/04/gWDMYimuxjFN45O.png)]

继续将E出队，在E出队之后，顶点F、C都变成了入度为0的顶点，统统入队：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WK3iupwG-1686205207156)(https://s2.loli.net/2022/09/04/uiXtEYK5aIWxNl4.png)]

此时继续将C出队，我们发现没有任何顶点入队变为0，我们继续来看F：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4i1nFyyi-1686205207157)(https://s2.loli.net/2022/09/04/ue1dkjGcLKg3TCY.png)]

当F出队后，顶点G变成了入度为0的顶点，此时将G入队：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nGLhhdzW-1686205207157)(https://s2.loli.net/2022/09/04/yqDC2BFQpElfz1L.png)]

剩下就是把G出队，然后F入队F再出队了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ksXxMeTR-1686205207158)(https://s2.loli.net/2022/09/04/2Na4UxFBJV6u3eR.png)]

最后得到的拓扑序列为：ADBECFGH，其实思路还是比较简单的，当然，其实我们利用拓扑排序算法可以检测一个有向图是否为有向无环图，也就是说顶点还没遍历完队列就空了的话，说明一定出现了回路。

关键路径计算

经过前面的学习，我们知道一个任务可能会存在前置任务，只不过我们仅仅是简单讨论了任务的完成顺序，如果此时我们为每个任务添加一个权重，表示任务所需要花费的时间，那么我们的后续任务就需要前置任务全部按时间完成之后才能继续：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2sTJbX6-1686205207158)(https://s2.loli.net/2022/09/04/uUPRtKrGBbXlNHi.png)]

比如A代表某个任务（事件），B代表另一个任务，我们需要先花费2天时间完成A之后，才能开始B，活动包括时间用边来表示，我们将边作为活动的图称为AOE图，每个事件对应着多个活动（多条边）它就像一个大工程一样，从A开始，中间需要经过各种各样的步骤，最后到H完工作为结束。

而我们需要计算的是那些最拖延工期的活动，比如要开始任务C，那么需要完成A、B才可以，完成A需要7天，完成B需要5天，由于C需要同时完成A和B才能继续，所以说A就变成了最拖延工期的任务，因为它的时间比B还长，B都完工了，还需要等待A完成才可以。只要计算出这些最拖延工期的任务，得到一条关键路径，我们就可以得到完成整个工程最早的时间以及各项任务可以在什么时候开工了。

我们来看看如何进行计算，我们以下图为例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IxoaMvEK-1686205207158)(https://s2.loli.net/2022/09/04/E8UqCQoylmLMuZA.png)]

我们需要计算两个东西，一个是事件最早完成时间（也就是要完成这个事件最快要多久），还有一个是事件最晚开始时间（就是这个事件在不影响工期的情况下最晚可以多久开始）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-owaThUwY-1686205207159)(https://s2.loli.net/2022/09/04/GeXishvJ5wmKUHW.png)]

我们依然是按照之前的拓扑排序的顺序进行，首先一开始是A，因为只有一个起点A肯定是可以直接开始的，所以说最早和最晚时间都是0（注意如果出现多个起点的话，最晚开始时间就不一定了），我们接着AOE图的工作顺序，来计算任务B和C的最早和最晚时间：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Us7nus0s-1686205207159)(https://s2.loli.net/2022/09/04/YFJonUm1x6H5AOl.png)]

接着就是D和E，首先D需要B和C同时完工之后才能继续，那么也就是说需要选择B和C过来时间最长的那一个：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8PEZWDo9-1686205207159)(https://s2.loli.net/2022/09/04/qo1ZwWgSji45uv3.png)]

最后就是F，到达F一共有三条路径，我们依然是选择最长的那一条，从D过来总共需要8天时间：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XAn8KITC-1686205207160)(https://s2.loli.net/2022/09/04/M4UzkX9ePgtSV2c.png)]

故整个工程的最早完成时间为8天，我们接着来看活动的最晚开始时间，现在我们要从终点倒着往回看：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EiwaSzJL-1686205207160)(https://s2.loli.net/2022/09/04/EsHI4DSYjWAVfvB.png)]

首先终点一定是8，因为工期最快是在8天结束的，我们继续倒着往回走，先来看E，E需要6天才能到达，但是只需要1天就可以结束，所以 8 - 1 = 7，最晚可以在第7天时动工：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y7Bg57Ez-1686205207160)(https://s2.loli.net/2022/09/04/8W2mo5D1vFN9ur6.png)]

然后是D，因为D到F需要2天时间，而D已经是第6天了，总时间8天，所以说D刻不容缓，第6天就需要马上开工：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VHqLmdrk-1686205207161)(https://s2.loli.net/2022/09/04/mTkRZXpP8necDyf.png)]

然后是C，C比较复杂，因为C有两个活动，一个是指向D的，一个是指向F的，我们需要单独计算每一个活动：

C -> F：用F的最晚开始时间减去任务时间 = 8 - 3 = 5，此时C最晚可以从第5天开始。
C -> D：用D的最晚开始时间减去任务时间 = 6 - 4 = 2，此时因为C的最早开始时间就是2，所以说C不能晚点开始。

综上，C不能晚点开始，只能从第2天就开始，因为要满足D的条件：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PyyZR1V0-1686205207161)(https://s2.loli.net/2022/09/04/7YbvfGVhlwO1yJR.png)]

最后是B，B也是有两个任务，一个是指向E一个是指向D：

B -> E：用E的最晚开始时间减去任务时间 = 7 - 3 = 4，此时B最晚可以第4天开工。
B -> D：用D的最晚开始时间减去任务时间 = 6 - 2 = 4，同上。

所以，B的最晚开始时间可以是第4天：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R95Flciu-1686205207161)(https://s2.loli.net/2022/09/04/oyInZ68SxJqYm5R.png)]

当然最后我们也可以计算一下A -> B和A -> C，但是由于只有这一个起点，所以说算出来肯定是0，当然如果出现多个起点的情况，还需要进行计算得到的。

计算完成之后，我们就可以得到关键路径了，也就是那些最早和最晚时间都一样的顶点（说明是刻不容缓的，时间很紧）这些顶点连成的路线，就是我们要找的关键路径了：A -> C -> D -> F，这条路径被安排的满满当当。关键路径上的所有活动都是关键活动，整个工期就是由这些活动在决定的，因此，我们可通过适当加快关键活动来缩短整个项目的工期，但是注意不能加快得太猛，因为如果用力过猛可能会导致关键路径发生变化。当然，关键路径并不是唯一的，可能会出现一样的情况。

至此，有关图结构相关的内容，我们就讲解到这里。

你可能感兴趣的:(数据结构,数据结构)

数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构 leetcode 算法
给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
【高阶数据结构】并查集椿融雪数据结构与算法数据结构并查集
文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
python中文版软件下载-Python中文版编程大乐趣
python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
Golang Channel PandaSkr golang
Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表英雄哪里出来《LeetCode算法全集》算法数据结构链表 c++归并排序
饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述将两个不降序链表合并为一个新的不降
数据结构 1 五花肉村长数据结构算法开发语言 c语言 visualstudio
1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法 leetcode b树
数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
【Python】数据结构,链表,算法详解 AIAdvocate python 数据结构链表排序算法广度优先深度优先
今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
AI教你学Python 第4天：函数和模块凡人的AI工具箱 AI教你学Python python 开发语言人工智能 AIGC
第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
C# Tuple、ValueTuple 語衣 C#知识补充 c#
栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
Rust中的所有权和借用规则详解代码云1 rust 开发语言后端
Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
二叉树--python 电子海鸥 Python数据结构与算法 python 开发语言数据结构
二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
java 线程池队列封装_java线程池（线程池组---分离任务队列和线程池）爱打怪的小魔女 java 线程池队列封装
线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
java的(PO,VO,TO,BO,DAO,POJO) Cb123456 VO TO BO POJO DAO
转: http://www.cnblogs.com/yxnchinahlj/archive/2012/02/24/2366110.html ------------------------------------------------------------------- O/R Mapping 是 Object Relational Mapping（对象关系映
spring ioc原理（看完后大家可以自己写一个spring） aijuans spring
最近，买了本Spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。先就IOC和DI谈一点我的看法。IO
MyEclipse 2014中Customize Persperctive设置无效的解决方法 Kai_Ge MyEclipse2014
高高兴兴下载个MyEclipse2014，发现工具条上多了个手机开发的按钮，心生不爽就想弄掉他！结果发现Customize Persperctive失效！！有说更新下就好了，可是国内Myeclipse访问不了，何谈更新... so~这里提供了更新后的一下jar包，给大家使用！ 1、将9个jar复制到myeclipse安装目录\plugins中 2、删除和这9个jar同包名但是版本号较
SpringMvc上传 120153216 springMVC
@RequestMapping(value = WebUrlConstant.UPLOADFILE) @ResponseBody public Map<String, Object> uploadFile(HttpServletRequest request,HttpServletResponse httpresponse) { try { //
Javascript----HTML DOM 事件何必如此 JavaScript html Web
HTML DOM 事件允许Javascript在HTML文档元素中注册不同事件处理程序。事件通常与函数结合使用，函数不会在事件发生前被执行！注：DOM：指明使用的 DOM 属性级别。 1.鼠标事件属性
动态绑定和删除onclick事件 357029540 JavaScript jquery
因为对JQUERY和JS的动态绑定事件的不熟悉，今天花了好久的时间才把动态绑定和删除onclick事件搞定!现在分享下我的过程。在我的查询页面，我将我的onclick事件绑定到了tr标签上同时传入当前行(this值)参数，这样可以在点击行上的任意地方时可以选中checkbox，但是在我的某一列上也有一个onclick事件是用于下载附件的，当
HttpClient|HttpClient请求详解 7454103 apache 应用服务器网络协议网络应用 Security
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。本文首先介绍 HTTPClient，然后根据作者实际工作经验给出了一些常见问题的解决方法。HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需
递归逐层统计树形结构数据 darkranger 数据结构
将集合递归获取树形结构: /** * * 递归获取数据 * @param alist:所有分类 * @param subjname:对应统计的项目名称 * @param pk:对应项目主键 * @param reportList: 最后统计的结果集 * @param count:项目级别 */ public void getReportVO(Arr
访问WEB-INF下使用frameset标签页面出错的原因 aijuans struts2
<frameset rows="61,*,24" cols="*" framespacing="0" frameborder="no" border="0">
MAVEN常用命令 avords
Maven库： http://repo2.maven.org/maven2/ Maven依赖查询： http://mvnrepository.com/ Maven常用命令： 1. 创建Maven的普通java项目： mvn archetype:create -DgroupId=packageName
PHP如果自带一个小型的web服务器就好了 houxinyou apache 应用服务器 Web PHP 脚本
最近单位用PHP做网站，感觉PHP挺好的，不过有一些地方不太习惯，比如，环境搭建。PHP本身就是一个网站后台脚本，但用PHP做程序时还要下载apache，配置起来也不太很方便，虽然有好多配置好的apache+php+mysq的环境，但用起来总是心里不太舒服，因为我要的只是一个开发环境，如果是真实的运行环境，下个apahe也无所谓，但只是一个开发环境，总有一种杀鸡用牛刀的感觉。如果php自己的程序中
NoSQL数据库之Redis数据库管理(list类型) bijian1013 redis 数据库 NoSQL
3.list类型及操作 List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作从链表的头部或者尾部添加删除元素，这样list既可以作为栈，又可以作为队列。 &nbs
谁在用Hadoop？ bingyingao hadoop 数据挖掘公司应用场景
Hadoop技术的应用已经十分广泛了，而我是最近才开始对它有所了解，它在大数据领域的出色表现也让我产生了兴趣。浏览了他的官网，其中有一个页面专门介绍目前世界上有哪些公司在用Hadoop，这些公司涵盖各行各业，不乏一些大公司如alibaba,ebay,amazon,google,facebook,adobe等，主要用于日志分析、数据挖掘、机器学习、构建索引、业务报表等场景,这更加激发了学习它的热情。
【Spark七十六】Spark计算结果存到MySQL bit1129 mysql
package spark.examples.db import java.sql.{PreparedStatement, Connection, DriverManager} import com.mysql.jdbc.Driver import org.apache.spark.{SparkContext, SparkConf} object SparkMySQLInteg
Scala: JVM上的函数编程 bookjovi scala erlang haskell
说Scala是JVM上的函数编程一点也不为过，Scala把面向对象和函数型编程这两种主流编程范式结合了起来，对于熟悉各种编程范式的人而言Scala并没有带来太多革新的编程思想，scala主要的有点在于Java庞大的package优势，这样也就弥补了JVM平台上函数型编程的缺失，MS家.net上已经有了F#，JVM怎么能不跟上呢？对本人而言
jar打成exe bro_feng java jar exe
今天要把jar包打成exe，jsmooth和exe4j都用了。遇见几个问题。记录一下。两个软件都很好使，网上都有图片教程，都挺不错。首先肯定是要用自己的jre的，不然不能通用，其次别忘了把需要的lib放到classPath中。困扰我很久的一个问题是，我自己打包成功后，在一个同事的没有装jdk的电脑上运行，就是不行，报错jvm.dll为无效的windows映像，如截图最后发现
读《研磨设计模式》-代码笔记-策略模式-Strategy bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化简单理解： 1、将不同的策略提炼出一个共同接口。这是容易的，因为不同的策略，只是算法不同，需要传递的参数
cmd命令值cvfM命令 chenyu19891124 cmd
cmd命令还真是强大啊。今天发现jar -cvfM aa.rar @aaalist 就这行命令可以根据aaalist取出相应的文件例如：在d：\workspace\prpall\test.java 有这样一个文件，现在想要将这个文件打成一个包。运行如下命令即可比如在d：\wor
OpenJWeb(1.8) Java Web应用快速开发平台 comsci java 框架 Web 项目管理企业应用
OpenJWeb(1.8) Java Web应用快速开发平台的作者是我们技术联盟的成员，他最近推出了新版本的快速应用开发平台 OpenJWeb(1.8)，我帮他做做宣传 OpenJWeb快速开发平台以快速开发为核心，整合先进的java 开源框架，本着自主开发+应用集成相结合的原则，旨在为政府、企事业单位、软件公司等平台用户提供一个架构透
Python 报错：IndentationError: unexpected indent daizj python tab 空格缩进
IndentationError: unexpected indent 是缩进的问题，也有可能是tab和空格混用啦 Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且在Python语言里，缩进而非花括号或者某种关键字，被用于表示语句块的开始和退出。增加缩进表示语句块的开
HttpClient 超时设置 dongwei_6688 httpclient
HttpClient中的超时设置包含两个部分： 1. 建立连接超时，是指在httpclient客户端和服务器端建立连接过程中允许的最大等待时间 2. 读取数据超时，是指在建立连接后，等待读取服务器端的响应数据时允许的最大等待时间在HttpClient 4.x中如下设置： HttpClient httpclient = new DefaultHttpC
小鱼与波浪 dcj3sjt126com
一条小鱼游出水面看蓝天，偶然间遇到了波浪。　　小鱼便与波浪在海面上游戏，随着波浪上下起伏、汹涌前进。　　小鱼在波浪里兴奋得大叫：“你每天都过着这么刺激的生活吗？简直太棒了。”　　波浪说：“岂只每天过这样的生活，几乎每一刻都这么刺激！还有更刺激的，要有潮汐变化，或者狂风暴雨，那才是兴奋得心脏都会跳出来。”　　小鱼说：“真希望我也能变成一个波浪，每天随着风雨、潮汐流动，不知道有多么好！”　　很快，小鱼
Error Code: 1175 You are using safe update mode and you tried to update a table dcj3sjt126com mysql
快速高效用：SET SQL_SAFE_UPDATES = 0；下面的就不要看了！今日用MySQL Workbench进行数据库的管理更新时，执行一个更新的语句碰到以下错误提示： Error Code: 1175 You are using safe update mode and you tried to update a table without a WHERE that
枚举类型详细介绍及方法定义 gaomysion enum javaee
转发 http://developer.51cto.com/art/201107/275031.htm 枚举其实就是一种类型，跟int, char 这种差不多，就是定义变量时限制输入的，你只能够赋enum里面规定的值。建议大家可以看看，这两篇文章，《java枚举类型入门》和《C++的中的结构体和枚举》，供大家参考。枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum
Merge Sorted Array hcx2013 array
Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. Note:You may assume that nums1 has enough space (size that is
Expression Language 3.0新特性 jinnianshilongnian el 3.0
Expression Language 3.0表达式语言规范最终版从2013-4-29发布到现在已经非常久的时间了；目前如Tomcat 8、Jetty 9、GlasshFish 4已经支持EL 3.0。新特性包括：如字符串拼接操作符、赋值、分号操作符、对象方法调用、Lambda表达式、静态字段/方法调用、构造器调用、Java8集合操作。目前Glassfish 4/Jetty实现最好，对大多数新特性
超越算法来看待个性化推荐 liyonghui160com 超越算法来看待个性化推荐
一提到个性化推荐，大家一般会想到协同过滤、文本相似等推荐算法，或是更高阶的模型推荐算法，百度的张栋说过，推荐40%取决于UI、30%取决于数据、20%取决于背景知识，虽然本人不是很认同这种比例，但推荐系统中，推荐算法起的作用起的作用是非常有限的。就像任何
写给Javascript初学者的小小建议 pda158 JavaScript
　　一般初学JavaScript的时候最头痛的就是浏览器兼容问题。在Firefox下面好好的代码放到IE就不能显示了，又或者是在IE能正常显示的代码在firefox又报错了。　　如果你正初学JavaScript并有着一样的处境的话建议你：初学JavaScript的时候无视DOM和BOM的兼容性，将更多的时间花在了解语言本身（ECMAScript）。只在特定浏览器编写代码（Chrome/Fi
Java 枚举 ShihLei java enum 枚举
注：文章内容大量借鉴使用网上的资料，可惜没有记录参考地址，只能再传对作者说声抱歉并表示感谢！一基础 1）语法枚举类型只能有私有构造器（这样做可以保证客户代码没有办法新建一个enum的实例）枚举实例必须最先定义 2）特性 &nb
Java SE 6 HotSpot虚拟机的垃圾回收机制 uuhorse java HotSpot GC 垃圾回收 VM
官方资料，关于Java SE 6 HotSpot虚拟机的garbage Collection，非常全，英文。 http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning &