| 这个作业属于哪个班级 | 数据结构-网络20 |
| ---- | ---- | ---- |
| 这个作业的地址 | DS博客作业04--图 |
| 这个作业的目标 | 学习图结构设计及相关算法 |
| 姓名 | 余智康 |

目录

0. 展示PTA总分

1. 本章学习总结

2. PTA实验作业

0.PTA得分截图

1.本周学习总结

本次所有总结内容，请务必自己造一个图（不在教材或PPT出现的图），围绕这个图展开分析。建议：Python画图展示。图的结构尽量复杂，以便后续可以做最短路径、最小生成树的分析。

该图引自被B站 "《空洞骑士》：人物关系图谱"，地址：https://www.bilibili.com/read/cv6403674/

修改后的关系图（部分）：

1.1 图的存储结构

1.1.1 邻接矩阵

造一个图，展示其对应邻接矩阵
邻接矩阵的结构体定义
建图函数

  • 结构体：
    • 1）顶点的结构体：顶点编号、其它信息
    • 2）图的结构体：二维数组(存放权值)、一维数组(存放顶点信息)、整型变量(存放顶点数、边数)
  #define MAXV 100   //最大顶点数
  typedef struct
  {
       int no;          //顶点编号
       InfoType info;   //其它信息
  }VertexType;          //顶点结构体

  typedef struct
  {
      int weight;  //边
      string relation;   //关系
  }EDGES;

  typedef struct 
  {
        EDGES edges[MAXV][MAXV];  //邻接矩阵
        int n,e;        //顶点数、边数
        VertexType vexs[MAXV];  //存放顶点信息
  }MatGraph;            //图的结构图

  • 存储：

    • 以 “空洞骑士关系图(部分)” 为例

  • 申请空间：
    1）因为0不使用，所以申请 node+1 个。
    2）先给二级指针申请 node+1 个存放一级指针的空间，再 循环 给每一个一级指针申请 node+1个 存放结点数据的空间

  	g.edges = new EdgesType * [node+1];
	for (i = 0; i <= node; i++)
	{
		g.edges[i] = new EdgesType[node+1];
	}
  • 建图（有向图）：
    • void CreatNode()，输入结点的信息：编号、名称，存放在 g.vexs[]数组中
    • void CreatMGraph()，
      1）创建邻接矩阵 ：①邻接矩阵初始化 -> ②输入结点编号，（输入权值），修改对应位置的权值 -> ③ g.e = e, g.n = n;
      1）建邻接矩阵的循坏条件，for i = 0 to e-1
  void CreatNode(MGraph &g, int n)  //输入结点信息
  {
      int No;

      for(int i=1; i<=n; i++)
      {
          cin >> No;
          g.vexs[No].no = No;
    
          cin >> g.vexs[No].info;
      }
  }

  void CreatMGraph(MGraph &g, int n, int e)
  {
        int i,j;  //循环计数变量
        int a,b;  
        
        //二维数组初始化
        for(i=0; i<=n; i++)
           for(j=0; j<=n; j++)
              g.edges[i][j] = 0;
  
        for(i=0; i<e; i++)
        {
           cin >>a >>b ;
           cin >>g.edges[a][b].relation >>g.edges[a][b].weight;
        }
        
        g.n = n;
        g.e = e;
  }

1.1.2 邻接表

造一个图，展示其对应邻接表（不用PPT上的图）
邻接矩阵的结构体定义
建图函数

  • 存储：

    • 以 “空洞骑士关系图(部分)” 为例

  • 结构体：

    typedef string InfoType,Vertex;
    typedef struct ANode  //边的结构体
    {
        int adjvex;  //终点编号
        struct ANode *nextarc; //下一条边的指针
        InfoType info;  //该边信息
        double weight;  //该边权值
    }ArcNode;   

    typedef struct Vnode  //结点的结构体
    {
        Vertex data;  //顶点信息
        ArcNode *firstarc;  //第一条边
    }VNode;

    typedef struct
    {
        VNode adjlist[MAXV];  //邻接表
        int n, e;
    }AdjGraph;
  • 建图:
    void CreatAdj(AdjGraph *&G, int n, int e)
    {
          定义 p 为 指向ArcNode数据类型的指针  
          G = new AdjGraph  G动态申请内存空间
          for i=o to n  do
               G->adjlist[i].firstarc = NULL  初始化
          end for
      
          for i=0 to e-1 do
                输入结点编号，a，b
                p 申请内存空间, 
                p -> adjvex = b；  b为终点编号
                头插法将 p 插入 G->adjlist[a].fistarc
          end for
   
          G->n = n; G->e = e;
     }

1.1.3 邻接矩阵和邻接表表示图的区别

各个结构适用什么图？时间复杂度的区别。

  • 邻接矩阵：
    • 适用于稠密图，稀疏图使用邻接矩阵会有较大的空间浪费
    • 因为需要遍历二维数组，时间复杂度为 O(n^2)
  • 邻接矩阵：
    • 适用于稀疏图
    • 时间复杂度为 O(n+e)

1.2 图遍历

1.2.1 深度优先遍历

选上述的图，继续介绍深度优先遍历结果
深度遍历代码
深度遍历适用哪些问题的求解。（可百度搜索）

  • "Wyrm"开始深度遍历结果：

    • Wyrm(1) -> The Pale King(3) -> Herrah the Beast(2) -> Hornet(5) -> The White Lady(4) -> Dryya(6) -> Hegemol(7) -> False Knight(13) -> Maggot(12) -> Isma(8) -> Ogrim(9) -> Ze'mer(10) -> The daught of The Lord(11)

  • 程序运行截图：

  • 深度遍历代码：

  void DFS(MGraph &g, int v)    
  {
      if(v > g.n)  return;      

      cout输出结点信息
      visited[v] = 1;  //标记为已读

      while (未遍历完 v 的出度结点)
      {
	   if 未访问过的结点 && 有权值  do
		DFS(g, i) 进行递归
           end if
          
           移动到 v 的下一个出度结点
      }
  }

1.2.2 广度优先遍历

选上述的图，继续介绍广度优先遍历结果
广度遍历代码
广度遍历适用哪些问题的求解。（可百度搜索）

  • "Wyrm"开始广度遍历结果：

    • Wyrm(1) -> The Pale King(3) -> Herrah the Beast(2) -> The White Lady(4) -> Hornet(5) -> Dryya(6) -> Heqemol(7) -> Isma(8) -> Ogrim(9) -> Ze'mer(10) -> False Knight(11) -> The daught of The Lord(13) -> Maggot(12)

  • 程序运行截图：

  • 广度遍历伪代码：

void BFS(MGraph g, int v)
{
    if （v 结点没有出度 ）  do 输出 v结点的信息  return

    queue<int>que;   //邻接表和临界矩阵中，队列类型均为 int型，之前邻接表犯过将其设为 ArcNode* 型的错误

    v 入队列
    记录 v 已经访问

    while(队列不空)
    {
        取队头，赋值到 p中；  并出队；
        cout 输出 p的信息
    
        now 赋值为 p第一个出度结点（邻接表中ArcNode*）

        while( p 的出度结点 未遍历 完)  do
          if 该出度结点未访问过 && 有权值 do
              该结点 编号 入队列；并记录为已访问
          end if
        end while
    }          
}
  • 问题的求解
      1. 只要找到问题的一种解决方式时，深度遍历比较快速，但不一定找到问题的最优解；
      1. 在问题存在多种解决方式时，广度遍历能给出全部可行的解决方案，可用于比较，从而选出最可能的解决方案；
      1. 深度遍历如本学期学习数据结构时，在线性表章节的迷宫寻路问题，一开始便是深度搜索找到一条路径；当不仅仅要找到走出迷宫的路径，还要比较多种路径，从而找出最短路径时，则使用了广度搜索。

1.3 最小生成树

用自己语言描述什么是最小生成树。

  • 自己的语言解释最小生成树：
    • 生成树：由图的 n 个顶点去掉多余的边由（n-1）条边连接的树。
    • 最小生成树：权值之和最小的生成树
    • 生成树是树，不是图，没有箭头。

1.3.1 Prim算法求最小生成树

基于上述图结构求Prim算法生成的最小生成树的边序列
实现Prim算法的2个辅助数组是什么？其作用是什么？Prim算法代码。
分析Prim算法时间复杂度，适用什么图结构，为什么？

  • Prim算法：

    • Prim算法构造最小生成树的过程就是将右边圆圈中“候选区”的结点不断选中并放入左边矩形的“选中区”中；

  • 辅助数组：

    • lowcost[i]: lowcost也就是“候选区”，表示以i为出度的边的最小权值。当lowcost[i] = 0时，表示 i 结点已经加入到了最小生成树中;
    • closet[i]: closet[i] 对应lowcost[i]的入度，则<closet[i],i>是最小生成树的一条边。其中 closet[i] = 0 表示以 i 结点作为树的根节点。

  • Prim算法操作：

  1. 初始化lowcost[]， 其中lowcost[i]的值为v为入度，i为出度的权
    值，权值为0 则置为INF(∞)；

  2. 初始化closet[]，其中closet[i] = v。

  3. 从lowcost[]中找到最小的点 j ，进入最小生成树。并将 lowcost[j] = 0；

  4. 遍历顶点，若 weight<j,i>小于 lowcost[i] 则修改 lowcost[i]，并修改closet[i]的入度为j。

  5. 循环3、4 总共进行 n-1 次，则n个顶点全部进入最小生成树；

    • Prim代码：
void Prim(MGraph g, int v)
{
	int* lowcost = new int[g.n + 1];
	int* closet = new int[g.n + 1];
	int min, node_min;
	int i, k;

	//1. 初始化lowcost[]， 其中lowcost[i]的值为v为入度，i为出度的权值，权值为0 则置为INF(∞)；
	//2. 初始化closet[]，其中closet[i] = v。
	for (i = 0; i <= g.n; i++)
	{
		if (g.edges[v][i].weight != 0)
		{
			lowcost[i] = g.edges[v][i].weight;
		}
		else
		{
			lowcost[i] = INF;
		}

		closet[i] = v;
	}
	lowcost[v] = 0;						
					  
	for (k = 0; k < g.n - 1; k++)
	{
		//3.  从lowcost[]中找到最小的点 j ，进入最小生成树。并将 lowcost[j] = 0；
		min = INF;
		for (i = 0; i <= g.n; i++)
		{
			if (lowcost[i] > 0 && lowcost[i] < min)
			{
				min = lowcost[i];
				node_min = i;
			}
		}
		lowcost[node_min] = 0;
		cout << closet[node_min] << " and " << node_min << " weight-> " << min << endl;

		//4. 遍历顶点，若 weight<j, i>小于 lowcost[i] 则修改 lowcost[i]，并修改closet[i]的入度为j。
		for (i = 0; i <= g.n; i++)
		{
			if (g.edges[node_min][i].weight != 0 && g.edges[node_min][i].weight < lowcost[i])
			{
				lowcost[i] = g.edges[node_min][i].weight;
				closet[i] = node_min;
			}
		}
	}
	//5.循环3、4 总共进行 n - 1 次，则n个顶点全部进入最小生成树； 

	delete[] lowcost;
	delete[] closet;
}

  • 敲Prim代码时的 错误日志

    • 错误一： 333 行 if (lowcost[i] != 0 && lowcost[i] < min) 误写为 if (lowcost[i] != 0 && min < lowcost[i])
    • 错误二： 误将 330行的 min = INF放入 for循环中，导致找不到最小值
    • 错误三： 339行、340行的 i 改为 node_min
    • 错误四： 343行-351行的 for循环 内使用了未初始化的 j，改为node_min
    • 错误五： 304、305行 new的空间 误写成 new lowcost = int[v+1]，导致申请的空间不足，出错。改为new lowcost = int[g.n + 1]
    • 错误六： 345行 if语句无需判断 lowcost[i] 是否为0， 改为判断 g.edges[node_min][i].weight 是否为0
    • 错误七： 312行 lowcost[g.n]最后一个结点没有初始化

  • Prim算法得到的边序列

  • Prim时间复杂度：

    • 两层for循环嵌套，时间复杂度 O(n^2)

  • Prim适用的图：

    • 由于Prim算法和边数无关，执行的次数和顶点个数 n 有关，故比较适合稠密图。

1.3.2 Kruskal算法求解最小生成树

基于上述图结构求Kruskal算法生成的最小生成树的边序列
实现Kruskal算法的辅助数据结构是什么？其作用是什么？Kruskal算法代码。
分析Kruskal算法时间复杂度，适用什么图结构，为什么？

  • Kruskal算法：

    • 1）ST 为空集
    • 2）按边的权值 从小到大 放入边集 E 中
    • 3）依次从 E 选择边放入 ST 中
    • 3）筛选时，若所选择的边放入 ST 中构成了回路，则 舍弃 该边
    • 4）返回步骤 3），直到 ST 中包含（n-1）条边
    • 备注：工具树 并查集 同一个根 回路

  • 辅助数组：

    • 1）边集合 E，按权值 从小到大 存放边，E的结构体里的数据项： 初始顶点、终止顶点、边的权值
    • 2）vset数组，用于并查集。存放每个结点的根，判断两个结点的根是否相同，从而判断是否在 同一个工具树 上，若在，则这两个结点会构成回路，舍弃该边。

  • Kruskal伪代码：

  for i=0 to G.n do
    vset[i] = i;  //初始化
  end for

  for i=1 to G.n do
    p = G.adjlist[i].firstacr;
    while p!=NULL do
        将 p 中的终点编号 和 权值 以及 i（起始结点编号）放入 E[]中
        p = p-> nextarc;    
    end while
  end for

  调用函数，将 E[]排序

  重置i，j未0
  while i < G.n-1 do
    取出 E[j]的结点编号，权值

    检查两个结点是否存在于同一个集合
    if vset[node_1] != vset[node_2]
        for k=0 to G.n
            修改集合编号
        end for
        输出
     end if
  end while

  • Kruskal算法得到的边序列

  • Kruskal时间复杂度：

    • 上面那个的 Kruskal 代码的时间复杂度应该为 O(n^2)。
    • 若将排序改为 堆排序，而且使用 并查集 ，则时间复杂度为 O(e log2 e)

  • Kruskal适用的图：

    • Kruskal 算法的时间复杂度为 O(e log2 e),与图的结点数 n 无关，仅与边数 e 有关。则适合于稀疏图

1.4 最短路径

1.4.1 Dijkstra算法求解最短路径

基于上述图结构，求解某个顶点到其他顶点最短路径。（结合dist数组、path数组求解）
Dijkstra算法需要哪些辅助数据结构
Dijkstra算法如何解决贪心算法无法求最优解问题？展示算法中解决的代码。
Dijkstra算法的时间复杂度，使用什么图结构，为什么。

  • **基于上图，求 结点 “Wyrm(1)”到 “Ogrim(9)”的最短路径。（图选的不成，这最短路径0.0）

    • Dijkstra:
      • S 已经选入的点的集合； T 为选入点的集合；
      • 1）若存在 <V0,vi>, 距离的值为<V0,Vi>弧上的权值；
      • 2）若不存在，则距离为 INF（无穷）；
      • 3）从 T 中选择一个距离值最小的顶点W，加入 S；
      • 4）在 W 加入 S 后，修改 T 中的距离值；
      • 重复 3）4）直到 S 中包含所有顶点；

  • 辅助数组:

    • 存放最短路径长度：一维数组 dist[]，源点 v 默认
      ）其中dist[j] 表示源点 -> 顶点 j 的最短路径长度。
      ）dist[2]=12 表示源点 -> 顶点 2 的最短路径长度为12

    • 存放最短路径：一维数组 path[]
      ) 一条最短路径用一个一维数组表示，如顶点1 -> 9的 最短路径为 1、3、9。表示为 path[] = {1,3,9}
      ）最短路径序列的前一项的顶点编号，无路径用 -1 表示

  • 结果: Wyrm(1) -> The Pale King(3) -> Ogrim(9)

  • 过程：

  • Dijkstra如何解决贪心算法的问题

    • 通过修改 dist[]数组，使每次选中的结点到源点的距离均是最短；
    • 代码：
  for(j=0;j<g.n;j++)
  {
    if s[j] == 0 
      if g.edges[u][j] < INF && dist[u]+g.edges[u][j] < dist[j] do
        { 
          dist[j]=dist[u]+g.edges[u][j];
          path[j]=u;
        }
   }
  • Dijkstra的时间复杂度，适合的图结构：
    • 两层 for循环 嵌套, O(n^2)
    • 适合 邻接矩阵 存储
    • 备注：Dijkstra算法 不适用于带负数权值的带权图求最短；
      —————不适用求最长路径：由于找到一个当前距离源点S最远的A点，则该段路径固定，但可能存在源点 S 到 B点，B点到A点，这两段加起来比 直接 S到A点更远。

1.4.2 Floyd算法求解最短路径

Floyd算法解决什么问题？
Floyd算法需要哪些辅助数据结构
Floyd算法优势，举例说明。
最短路径算法还有其他算法，可以自行百度搜索，并和教材算法比较。

  • Floyd算法的辅助数组：

    • 二维数组 A 存放当前顶点之间的最短路径长度，如 A[i][j]表示当前顶点i到顶点j的最短路径长度
    • 完了这个蛤子Floyd看不懂，来不及了，来不及了，这个就放着吧(；′⌒`)

  • Floyd算法解决哪些问题：

  • Floyd算法的优势：

  • 其它最短路径的算法：

1.5 拓扑排序(

找一个有向图，并求其对要的拓扑排序序列
实现拓扑排序代码，结构体如何设计？
书写拓扑排序伪代码，介绍拓扑排序如何删除入度为0的结点？
如何用拓扑排序代码检查一个有向图是否有环路？

  • 找一个有向图，并求其对要的拓扑排序序列

  • 拓扑排序序列：

    • 1）有向图中删去一个 没有前驱 的顶点，输出；
    • 2）删去 以该顶点为 尾 的弧；
    • 3）重复 1）2）直至 图空 ，或 图不空但找不到无前驱顶点 为止
    • 备注： 若图不空 但找不到无前驱顶点，则是 存在环

  • 上图 拓扑排序 结果：

  • 拓扑排序结构体：

    • !表头结点增加了 顶点入度的数据项
  typedef struct
  {
      vertex data;  //顶点信息
      int count;    //入度
      ArcNode* firstarc;   //第一条弧
  }VexNode;
  • 拓扑排序伪代码：
  遍历邻接表
    计算每个顶点的入度，存放在 表头结点的 count 中
  遍历图顶点
    将 入度为0 的顶点，入栈， 删除该结点
  while 栈不空 do
    出栈，v 结点 p = G->adjlist[v].firstarc
    while p != NULL do
      v 所有邻接点的入度 -1；
      若 此时 入度为0 则入栈， 并在图中删去该结点
      p = p->nextarc;
    end while
  end while

  • 拓扑排序删去结点：

    • 类似链表的删除操作
    • 1）先判断 v 结点的第一条弧是否为空
    • 2）判断第一个邻接点 的入度在 -1后 是否为 0
    • 2） ① 若 -1后入度为0，则将该邻接点入栈。 并修改表头结点的 firstarc 为 该邻接点的nextarc，再delete掉该邻接点。最后重复 2）直到第一个邻接点的入度不为 0 或是 第一个邻接点不存在
    • 2） ② 若 -1后入度不为0，则 p = firstarc，以 while(!p->nextarc)为循环条件，if(G->adjlist[p->nextarc.adjvex].count == 0) 则 用 temp存放 p->nextarc, 再 p = p->nextarc->nextarc，最后delete temp

  • 检查一个有向图是否有环路：
    * 1）在拓扑排序时，把有向图的顶点 真正上删除 ，然后再拓扑排序完遍历一下，看看图是否为空。若图不为空，则有环。
    * 1）或者，假的删除，将拓扑排序中删去的顶点的 count 项赋值为 -1.拓扑排序完，统计是否有结点的 count 项不为 -1，则有环

1.6 关键路径(

什么叫AOE-网？
什么是关键路径概念？
什么是关键活动？

  • AOE-网：

    • AOE网 为带权值的有向无环图；
    • 顶点 为事件或状态；
    • 弧 为活动发生的先后关系；
    • 权值 为活动持续的时间
    • 起点 入度为 0 的顶点 （仅有一个）
    • 终点 出度为 0 的顶点 （仅有一个）

  • 关键路径概念：

    • 关键路径 为源点到汇点的 最长 路径， -> 转变为图的最长路径问题
    • 备注： 求图的最长路径 不能 使用求最短路径的 Dijkstra算法实现。

  • 关键活动：

    • 关键活动： 在关键路径上的活动 都是关键活动
    • 关键活动不存在富余时间

2.PTA实验作业

2.1 六度空间

选一题，介绍伪代码，不要贴代码。请结合图形展开分析思路。

2.1.0 思路

  • 计数，距离不超过6
  • 遍历
  • 层次遍历！ 如树的层次遍历并输出高度， 队列！lastNode！

2.1.1 伪代码（贴代码，本题0分）

  建图；
  for i=1 to G->n do
    //CountNode(G,6,i)用于依次求得 每个顶点距离6以内的顶点数，并返回
    proportion = (double)CountNode(G, 6, i) * 1.0 / node * 100;
    输出
  end for

  int CountNode(AdjGraph* G, int distance, int v)
    v 入队列，并标记为已读，同时count++ //（每次有数据进入队列，则count++）

    while 队列不空 do
      取队头，出队
      取队头 的第一条弧 // p = firstarc
      while p 不为空
        若p->No结点未访问过，入队列，已访问，count++
        p移动到 p->nextarc
      end while
    end while

2.1.2 提交列表

2.1.3 本题知识点

  • 图的层次遍历
  • 层次遍历中使用 lastNode 确定距离

2.2 旅游规划

2.2.1 思路：

  • 最短路径 -> Dijkstra算法 -> 邻接矩阵 -> 无向图还是有向图 （思考：先试用有向图）
  • 相同距离 取费用最低 -> Dijkstra算法使用时遇到多个相同的路径长度，path用二维数组（思考：string是否有一维数组的数据类型，可否使用），dist使用二维数组，与path对应。同时新引入一维cost数组，用于比较费用 -> 得出适合路径。
  • （思考：邻接矩阵的二维数组是否可以使用结构体，用来存放距离和花费）

2.2.1 伪代码（贴代码，本题0分）
伪代码为思路总结，不是简单翻译代码。

部分结构体
typedef struct
{
    int dist;
    int cost;
}DIST_COST;

typedef struct
{
    DIST_COST** edges; 
    int n,e;
}MGraph;

建图

......

2.2.2 提交列表
2.2.3 本题知识点