DS博客作业04--图

0.PTA得分截图

1.本周学习总结(0-5分)

1.1 总结图内容

基本概念特点

  • 图分为有向图和无向图

  • 若一个图中有n个顶点和e条边,每个顶点的度为di(0≤i≤n-1),则有:

图的存储结构

邻接矩阵

  • 顶点表存放顶点信息

  • 邻接矩阵存放边的信息

  • 特点:
    邻接矩阵取边直接,因此对顶点出入度的情况也较易掌握。
    邻接矩阵适合用于稠密图

结构定义
#define  MAXV  <最大顶点个数>	

typedef struct 
{    int no;			//顶点编号
     InfoType info;		//顶点其他信息
} VertexType;

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

 MatGraph g;//声明邻接矩阵存储的图

此为最基本的邻接矩阵结构定义,该邻接矩阵定义简单栈区申请,当顶点数较大时,我们需要到堆区申请。
  • 注意二级指针的写法如下:

为二级指针申请完地址后,要利用循环依次为每个一级指针申请地址
以上邻接矩阵的基本结构定义中,顶点的相关信息有另外定义结构体存储信息,我们可以根据需求自行定义。
*如通常如果顶点只有编号区分,甚至直接以数字顺序为编号时,而无其他信息时,我们也可以选择像上述邻接矩阵一样,直接用一维数组表示顶点。
 而经常,当边的信息不止包含长度,如带权值,带费用等其他信息时,此时我们也需要,另外定义一个结构体,来专门存储边的相关信息
  • 对边另定义结构体,且无需另外的顶点信息写法参考如下:
typedef struct 
{
	int length;
	int cost;
}edge;

typedef struct
{
	int edge[MAXV][MAXV];
	int n, e;
}MGraph;
  • 将上述注意点结合起来,对边另定义结构体,且动态申请的方法这样写:

邻接表

基本概念特点
  • 邻接表是一种顺序分配和链式分配相结合的存储结构。
    (即利用数组和链表相结合)

  • 用数组存储每条链头结点(头结点即每个顶点),链结点存储的是边的内容(存储该顶点的邻接表或出边)。

    头结点结构定义,需存储顶点信息即其后继边,保存后继关系。

    链表结点保存边内容,包含该边所连终点编号,以及链的后继关系(但要注意,并非是边与边的后继关系。实际上是头结点顶点与边终点的后继关系

    利用一维数组保存头结点,称为邻接表

结构体定义
typedef struct Vnode
{    Vertex data;			//顶点信息
     ArcNode *firstarc;		//指向第一条边
}  VNode;//头结点数组

typedef struct ANode
{     int adjvex;			//该边的终点编号
      struct ANode *nextarc;	//指向下一条边的指针
      InfoType info;		//该边的权值等信息
}  ArcNode;//链表节点,存边内容

typedef struct 
{     VNode adjlist[MAXV] ;	//邻接表
       int n,e;			//图中顶点数n和边数e
} AdjGraph;

AdjGraph *G;//声明一个邻接表存储的图G

  • 结合图像理解:
    蓝框部分的头结点紧密相连,就如数组地址相邻
    而橙框部分,则是链式结构,指针相连。

构造图

构造邻接矩阵
void CreateMGraph(MGraph& g, int n, int e)//建无向图
{
	int a,b;
	for (int i = 1; i <= e; i++)
	{
		cin >> a >> b;
		g.edges[a][b] = 1;
		g.edges[b][a] = 1;
	}
	g.e = e; g.n = n;
}
  • 由代码可知

  • 此邻接矩阵沿着对角线对称,因此为无向图

  • 若建有向图则直接:

g.edges[a][b] = 1;
建邻接表
void CreateAdj(AdjGraph*& G, int n, int e)//创建图邻接表
{
	int i, a, b;
	G = new AdjGraph;
	ArcNode* p;

	for (i = 1; i <= n; i++)//初始化头结点都指向空
	{
		G->adjlist[i].firstarc = NULL;
		G->adjlist[i].data = i;
	}

	for (i = 1; i <= e; i++)//根据输入的边
	{
		cin >> a >> b;

		p = new ArcNode;
		p->adjvex = b;
		p->nextarc = G->adjlist[a].firstarc;//头插入邻接表
		G->adjlist[a].firstarc = p;

		p = new ArcNode;//无向图则需要双向指向
		p->adjvex = a;
		p->nextarc = G->adjlist[b].firstarc;
		G->adjlist[b].firstarc = p;
	}

	G->n = n; G->e = e;
}
  • 同样此为无向图,若建有向,则如注释忽略
邻接表与邻接矩阵的相互转换

图的遍历

  • 概念:从图中的某个顶点开始,以某种搜索方式,对图中的其他顶点仅访问一次

  • 无论是广度优先遍历还是深度优先遍历,通常使用数组visited[]来标记顶点是否被访问,通常定义成全局变量。

深度优先遍历(DFS)

  • 类似迷宫问题:利用栈或者递归

  • 这里我们使用递归的方法对其邻接点不断遍历。

  • 遍历过程思路

邻接表的深度遍历
邻接表的深度遍历

void DFS(AdjGraph* G, int v)//v节点开始深度遍历 
{
	ArcNode* p;
	visited[v] = 1;
	
	cout << v;
	p = G->adjlist[v].firstarc;
	while (p)
	{
		if (visited[p->adjvex] == 0)
		{
			DFS(G, p->adjvex);
		}
		p = p->nextarc;
	}
}
邻接矩阵的深度遍历
邻接矩阵的深度遍历
void DFS(MGraph g, int v)//深度遍历 
{
	int i;
	visited[v] = 1; cout << v;

	for (i = 1; i <= g.n; i++)//循环查找是否有边
	{
		if (visited[i]==0&&g.edges[v][i] == 1)
		{
			DFS(g, i);
		}
	}
}
  • 注意由于邻接矩阵的写法:
    无法知道那些边与v结点是直接相连,因此只能通过循环找点判断边是否存在,并且判断点是否被访问过
 由遍历思路我们可知,我们是顺着连通的顶点不断遍历下去,因此**一旦图为非连通图,我们调用函数,就只能遍历该起点顶点所在的部分连通图**

 因此特别的,考虑到图可能为非连通图的情况,我们做出以下改善:

 非连通图调用过一次函数后,仍有其他点未被遍历。我们通常在**主函数中循环判断各顶点是否被遍历过,再决定是否再次调用深度遍历函数**
  • 注意判断在主函数中做,DFS函数仅做连通图的深度遍历。

广度优先遍历(BFS)

  • 同样类似迷宫问题,利用队列保存每层结点。

  • 广度优先遍历思路

邻接表的广度优先遍历
邻接表的广度优先遍历
void BFS(AdjGraph* G, int v) //v节点开始广度遍历   
{
	queue<VNode>Q;
	ArcNode* p; Vnode front;
	visited[v]=1;
	Q.push(G->adjlist[v]);

	while (!Q.empty())
	{
		front = Q.front();
		Q.pop();
		cout << front.data ;
		p = front.firstarc;
		
		while (p!=NULL)
		{
			if (visited[p->adjvex] == 0)
			{
				Q.push(G->adjlist[p->adjvex]);
				visited[p->adjvex] = 1;
			}
			p = p->nextarc;
		}
	}
	
}

邻接矩阵的广度优先遍历
邻接矩阵的广度优先遍历
void BFS(MGraph g, int v)//广度遍历 
{
	int Q[MAXV];
	int f=0, r=0;//队的首尾指针

	visited[v] = 1;
	Q[++r] = v;//入队
	while (f != r)//队不空
	{
		f++;
		cout << Q[f];//出队

		for (int i= 1; i <= g.n; i++)//同样需要循环每个顶点判断是否有边
		{
			if (visited[i]==0&&g.edges[Q[f]][i] == 1)//未被广度遍历过
			{
				visited[i] =1 ;
				Q[++r] = i;//入队
			}
		}
	}
}
- 注意邻接矩阵这里的队列,我们用了自己写的简易顺序队列:
  首尾指针是: int f=0, r=0;

- 同样的与邻接表相比,无法直接知道于其有边的点,因此也是需要通过**循环查找每个点判断是否有边存在**

DFS,BFS遍历图判断图是否连通

!!多次调用函数遍历的,记得要先将visited[]数组初始化
DFS图不连通的问题已经在上面阐述过了:
  我们只需在主函数中,第一次调用DFS函数后,若有出现仍未被遍历的点,则说明是非连通图。

  并且只要继续调用DFS,就可做到将非连通图中的各个连通部分都分别遍历完毕。

关于BFS图是否连通问题:
  判断BFS图是否连通的办法一样,一次执行后也是利用循环判断点是否全都被遍历。

  但由于BFS函数并不是通DFS一样递归写法,因此也用循环判断点是否被遍历这个写法,

  1.可以在BFS函数中,将所有内容都嵌套在循环内,主函数一次调用。
  2.当然也可以还是一样,循环在主函数中写。

最小生成树

基本概念

  • 生成树:一个连通图的生成树是一个极小连通子图,它含有图中全部n个顶点和构成一棵树的(n-1)条边。不能回路。 

  • 且生成树并不唯一
    利用深度优先遍历,我们可以得到深度优先生成树
    利用广度优先遍历,我们可以得到广度优先生成树

图示:

  • 最小生成树:对于带权值的图,其中权值之和最小的生成树称为图的最小生成树。
非连通图和最小生成树(容易忽略)

- 生成树的过程一定是在一个连通图才能完成,因此非连通图必须多次调用最小生成树函数,为其多个不同连通部分生成树

- 所有连通分量的生成树组成非连通图的生成森林。

普利姆算法(Prim)

设置2个辅助数组:

1.closest[i]:最小生成树的边依附在U中顶点编号。

2.lowcost[i]表示顶点i(i ∈ V-U)到U中顶点的边权重,取最小权重的顶点k加入U。
并规定lowcost[k]=0表示这个顶点在U中

每次选出顶点k后,要队lowcost[]和closest[]数组进行修正

伪代码设计过程

具体代码

void Prim(MGraph g, int v)
{
	int lowcost[MAXV],  closest[MAXV];//lowcost表示到该点最短距离,closest
	int i, j, k, min ;// k记录最近顶点的编号

	lowcost[1] = 1;//起点最近点为它本身
	for (i = 1; i <= g.n; i++)	//顶点从1开始,给lowcost[]和closest[]置初值
	{
		lowcost[i] = g.edges[v][i];//建图时未有直接相连的边,lowcost=edges为无穷大INF
		closest[i] = v;
	}
	for (i = 1; i < g.n; i++)	  //找(n-1)次剩下的顶点
	{
		min = INF;
		for (j = 1; j <= g.n; j++) //     在(V-U)中找出离U最近的顶点k
			if (lowcost[j] != 0 && lowcost[j] < min)
			{
				min = lowcost[j];  k = j; //
			}
		lowcost[k] = 0;		//遍历所有点后找到距离最近点,标记k已经加入

		for (j = 1; j <= g.n; j++)	//修改数组lowcost和closest
			if (lowcost[j] != 0 && g.edges[k][j] < lowcost[j])
			{
				lowcost[j] = g.edges[k][j];
				closest[j] = k;
			}
	}
}

应用-公路村村通题目分析

1. 本题有所给数据造成不畅通情况,其实就是图不连通情况。因为选过的点我们用lowcost[]=0来表示,因此可通过遍历lowcost数组,若每个点都被选入即畅通,反之则不畅通。

2. 若不畅通根据题目要求直接输出返回,若畅通,此时我们就根据closest数组计算最低预算。因为通过closest[]数组可以知道包含全点的最短路径,closrst[]所表示的就应该是该点的前驱点

克鲁斯卡尔算法(kruscal)

- 按权值的递增次序选择合适的边来构造最小生成树的方法


- 克鲁斯卡尔算法过程:

(1)置U的初值等于V(即包含有G中的全部顶点),TE(最小生成树的边集)的初值为空集(即图T中每一个顶点都构成一个连通分量)。
(2)将图G中的边按权值从小到大的顺序依次选取:
             若选取的边未使生成树T形成回路,则加入TE;
             否则舍弃,直到TE中包含(n-1)条边为止。

-由于克鲁斯卡尔算法过程是对边的权重排序选边,因此我们需要另外一个存储结构来存储边的权重信息

typedef struct 
{    int u;     //边的起始顶点
     int v;      //边的终止顶点
     int w;     //边的权值
} Edge; 

Edge E[MAXV];
  • 我们利用树的并查集来解决判断是否有环路问题

具体代码实现

void Kruskal(AdjGraph *g)
{ int i,j,k,u1,v1,sn1,sn2;
  UFSTree t[MAXSize];//并查集,树结构
   ArcNode  *p;
   Edge E[MAXSize];
   k=1;			//e数组的下标从1开始计
   for (i=0;i<g.n;i++)	//由g产生的边集E
	{   p=g->adjlist[i].firstarc;
        while(p!=NULL)    
	  {	E[k].u=i;E[k].v=p->adjvex;
            E[k].w=p->weight;
		k++; p=p->nextarc;
	  }
   HeapSort(E,g.e);	//采用堆排序对E数组按权值递增排序
   MAKE_SET(t,g.n);	//初始化并查集树t
  k=1;       	//k表示当前构造生成树的第几条边,初值为1
  j=1;       		//E中边的下标,初值为1
  while (k<g.n)     	//生成的边数为n-1
  {  u1=E[j].u;
     v1=E[j].v;		//取一条边的头尾顶点编号u1和v2
     sn1=FIND_SET(t,u1);
     sn2=FIND_SET(t,v1); //分别得到两个顶点所属的集合编号
     if (sn1!=sn2) //两顶点属不同集合
     {  printf("  (%d,%d):%d\n",u1,v1,E[j].w);
	  k++;		//生成边数增1
	  UNION(t,u1,v1);//将u1和v1两个顶点合并
     }
     j++;   		//扫描下一条边
  }
}

最短路径

  • 最短路径与最小生成树不:

    最小生成树需要包含所有顶点, 而最短路径只考虑路径最短,

Dijkstra算法

1.从T中选取一个其距离值为最小的顶点W, 加入S

2.S中加入顶点w后,对T中顶点的距离值进行修改:
   若加进W作中间顶点,从V0到Vj的距离值比不加W的路径要短,则修改此距离值;

3.重复上述步骤1,直到S中包含所有顶点,即S=V为止。

伪代码设计思路

这里我们同Prim算法建最小生成树的过程来比较看看,方便记忆:

1.Prim建成最小生成树和Dijkstra求最短路径,这两种方法的大致过程框架看起来似乎很相似。似乎都是选出最近临近点,记录选入,然后修正数组值。

2.求最短路径多了s[]数组来记录已选入的点,而生成最小树时直接由lowcost[]=0来表示已选入的点。这是由于dist[]数组最终获得的数据是源点到各点的最短距离,记录过程中不能轻易改变,而生成最小树lowcost[],是一边走一边选并且修正未选入点的距离值。因此已选入点的lowcost[]信息就可以置空来表示,而求最短路径时只能另辟数组s[]来存。

3.关于修正过程都是注意选入新点后最短路径是否发生了改变。最小生成树时,是需要边选点k边修正两个顶点集合间的最短路径,修正时只要注意选入该点后两集合间的最短路径是否改变。
  而相比最短路径,最短路径中不一定包含所有的点,因此即使选入点u后,是将带选入点u的路径与当前最短路径相比较取较小。

具体代码

void Dijkstra(MGraph g, int v)//源点v到其他顶点最短路径 
{
	int dist[MAXV], path[MAXV],s[MAXV];
	int mindistance,u;//u为每次所选最短路径点

	for (int i = 0; i < g.n; i++)//初始化各数组
	{
		s[i] = 0;//初始已选入点置空
		dist[i] = g.edges[v][i];//初始化最短路径

		if (dist[i] < INF) path[i] = v;
		else path[i] = -1;//即无直接到源点V的边,因此初始化为-1
	}
	s[v] = 1;//源点入表示已选

	for (int j = 0; j < g.n; j++)//要将所有点都选入需循环n-1次
	{
		mindistance = INF;//每次选之前重置最短路径
		for (int i = 1; i < g.n; i++)//每次都遍历源点以外其他点来选入点
		{
			if (s[i] == 0 && dist[i] < mindistance)//在未选的点中找到最短路径
			{
				mindistance = dist[i];
				u = i;//u记录选入点
			}
		}
		s[u] = 1;//最后记录的u才为最后选入点

		for (int i = 1; i < g.n; i++)//修正数组值
		{
			if (s[i] == 0)//!!仅需修改未被选入点的,已选入的既定
			{
				if (g.edges[u][i] < INF && dist[u] + g.edges[u][i] < dist[i])//先判断选入点到与该点存在时再比较判断
				{
					dist[i] = dist[u] + g.edges[u][i];
					path[i] = u;
				}
			}
		}
	}
	Dispath(dist, path, s, g.n, v);

}

Dijkstra算法特点:

1.不适用带负权值的带权图求单源最短路径。
  
2.  不适用求最长路径长度:
	最短路径长度是递增
	顶点u加入S后,不会再修改源点v到u的最短路径长度
        (按Dijkstra算法,找第一个距离源点S最远的点A,这个距离在以后就不会改变。但A与S的最远距离一般不是直连。)

Floyd算法

  • 该算法思路较简单:
就是不断将每个顶点都加入的过程中,同时不断更新最短路径矩阵**
算法思路

- 有向图G=(V,E)采用邻接矩阵存储

- 二维数组A用于存放当前顶点之间的最短路径长度,分量A[i][j]表示当前顶点i到顶点j的最短路径长度。

- 递推产生一个矩阵序列A0,A1,…,Ak,…,An-1
     Ak+1[i][j]表示从顶点i到顶点j的路径上所经过的顶点编号k+1的最短路径长度。

具体代码

void Floyd(MatGraph g)		//求每对顶点之间的最短路径
{
	int A[MAXVEX][MAXVEX];	//建立A数组
	int path[MAXVEX][MAXVEX];	//建立path数组
	int i, j, k;

	for (i = 0; i < g.n; i++)
		for (j = 0; j < g.n; j++)
		{
			A[i][j] = g.edges[i][j];
			if (i != j && g.edges[i][j] < INF)
				path[i][j] = i; 	//i和j顶点之间有一条边时
			else			 //i和j顶点之间没有一条边时
				path[i][j] = -1;
		}

	for (k = 0; k < g.n; k++)		//求Ak[i][j]
	{
		for (i = 0; i < g.n; i++)
			for (j = 0; j < g.n; j++)
				if (A[i][j] > A[i][k] + A[k][j])	//找到更短路径
				{
					A[i][j] = A[i][k] + A[k][j];	//修改路径长度
					path[i][j] = k; 	//修改经过顶点k
				}
	}
}

拓扑排序及关键路径

拓扑排序基本概念特点

  • 拓扑序列:在一个有向图中找一个拓扑序列的过程称为拓扑排序。

  • 序列必须满足条件:
     每个顶点出现且只出现一次。
     若存在一条从顶点 A 到顶点 B 的路径,那么在序列中顶点 A 出现在顶点 B 的前面。

  • 拓扑排序:在一个有向无环图中找一个拓扑序列的过程称为拓扑排序。

注意必须是有向无环图
排序过程
- 1.从有向图中选取一个没有前驱的顶点,并输出之;

- 2.从有向图中删去此顶点以及所有以它为尾的弧;
	
- 3.重复上述两步,直至图空,或者图不空但找不到无前驱的顶点为止。

根据此排序规则,我们对下图进行拓扑排序

得到的拓扑序列为:C1--C2--C3--C4--C5--C7--C9--C10--C11--C6--C12--C8
 或: C9--C10--C11--C6--C1--C12--C4--C2--C3--C5--C7--C8

由此可知,拓扑序列并未是唯一的

伪代码

- 需注意的是,我们不仅可以栈结构来保存要删除的前驱点,我们**同样可以使用队列**

- 但正是**由于栈和队列出入方式的不同**,所以同一个有向图,我们得到的可能就是不同的拓扑序列

具体代码

void TopSort(AdjGraph* G)//邻接表拓扑排序
{
	ArcNode* p;
	int stack[MAXV], top=-1;//顺序栈结构
	int visitedcout = 0;//记录已得到的拓扑序列长度
	int sequence[MAXV];//用于保存拓扑序列

	for (int i = 0; i < G->n; i++)
	{
		G->adjlist[i].count = 0;
	}
	for (int i = 0; i < G->n; i++)//遍历每条链,记录每个节点的入度
	{
		p = G->adjlist[i].firstarc;
		while (p)
		{
			G->adjlist[p->adjvex].count++;
			p = p->nextarc;
		}
	}

	for (int i = 0; i < G->n; i++)//先遍历图顶点,找出入度为0的点入栈
	{
		if (G->adjlist[i].count == 0)
		{
			top++; stack[top] = i;
		}
	}

	int i = 0;
	while (top!=-1)//接下来通过不断出栈过程中同时判断是否有点要入栈
	{
		sequence[i] = stack[top]; visitedcout++;//保存拓扑序列,并且记录已遍历点
		p = G->adjlist[stack[top]].firstarc;//则该点的后继点入度都要减一
		top--;//出栈

		while (p)
		{
			G->adjlist[p->adjvex].count--;
			if (G->adjlist[p->adjvex].count == 0)
			{
				top++; stack[top] = p->adjvex;
			}
			p = p->nextarc;
		}
		i++;
	}

	if (visitedcout == G->n)//则无环路得到拓扑序列,
	{
		cout << sequence[0];
		for (int i = 1; i < G->n; i++)
		{
			cout << " " << sequence[i];
		}
	}
	else cout << "error!";
}
关于如何判断图是否存在有环

- 举最简单的例子,由上图可知,在一个环路中,我们是没办法找到入度为0的顶点。
  同样的全局图来说,即使利用拓扑排序可以得到一定的拓扑序列,但只要存在环路,就不可能得到完整的拓扑序列

- 因此判断是否存在有环,只需记录一下得到的序列长度,与图的顶点数相比即可知,序列是否完整,是否就是拓扑序列
 
- 具体实现也已经在上述具体代码中体现

关键路径基本概念

  • AOE-网(Activity ON Edge Network):
    用顶点表示事件,用有向边e表示活动,边的权c(e)表示活动持续时间。是带权的有向无环图
    整个工程完成的时间为:从有向图的源点到汇点的最长路径。又叫关键路径

如何求关键事件和关键路径

求关键事件

事件v最早开始时间ve(v):v作为源点事件最早开始时间为0。

由于v为源点事件最早开始时间一定是前驱事件已完成。因此:
当v为初始源点时: ve(v)=0  					
          其余:ve(v)=MAX{ve(x)+a,ve(y)+b,ve(z)+c}	



事件v的最迟开始时间vl(v):定义在不影响整个工程进度的前提下,事件v必须发生的时间称为v的最迟开始时间

由于最迟时间要保证后继事件能完成,因此取最小
当v为终点时:vl(v)=ve(v)					
       其他 vl(v)=MIN{vl(x)-a,vl(y)-b,vl(z)-c}	



- 关键路径点:ve=vl

注意:计算:ve(i)最早开始和vl(i)最迟开始必须在拓扑有序和逆拓扑有序计算

活动:边的最早开始时间和最迟开始时间

1.活动a(边)的最早开始时间e(a)指该活动起点x事件的最早开始时间e(a)=ve(x)

2.活动a的最迟开始时间l(a)指该活动终点y事件的最迟开始时间与该活动所需时间之差
l(a)=vl(y)-c


- 关键活动:d(a)=l(a)-e(a),若d(a)为0,则称活动a为关键活动。

求关键路径

1.2.谈谈你对图的认识及学习体会。

  • 图的应用感觉比之前学的结构更加广了,实际应用在地图啊什么的比较多,好比村村通应用最小生成树问题,最短路径问题,还有关键路径。

  • 练习编程的题目,感觉其实思路都是比较直接,实质明显,最小生成树问题啊,最短路径问题。
    后面做阅读代码部分的时候,有一些题目的时候都是没什么思路,看了解法,才发现其实是所学知识的变化、延展。比如下面阅读代码的无向图的“拓扑”,所以阅读时候也对思路进行认真分析

  • 还有一个感觉就是图部分的编程对前面所学知识应用的更多,结合的内容更多,对编程能力更有考验。前面学习完栈和队列后对STL库的应用就会比较多,然后在这次复习题的代码中也会经常发现,
    对于一些简单的变量类型和简单的处理,有的时候我们自己写顺序栈,顺序队的其实也很简单。还有啊比如Kruscal算法的代码利用并查集,这就是并查集的应用结合。

  • 学习体会:一开始学图,对于图的存储结构,邻接矩阵和邻接表,相比起树的存储结构,感觉其实更好理解。还有图的遍历,深度优先,广度优先遍历,在前面树已学的基础下,对这部分内容感觉更加得心应 手。但是后面关于最小生成树,最短路径,以及拓扑序列集关键路径,这三部分内容,自己预习的时候就是明显感觉到,有点难理解,然后经过课上老师讲解后理解了算法的执行过程后,最后主要的压力还是得要自己去编写,去细细品代码的具体细节。

2.阅读代码

2.1 题目及解题代码

题目:最小高度树

解题代码

class Solution {
public:
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
	vector<int> indegree(n);//入度数组
	vector<vector<int>> graph(n);//图形表示
	vector<int> result;
	for (int i = 0; i < n; i++)
	{
		indegree[i] = 0;//初始化入度序列为0
		graph.push_back(v);
	}
	for (int i = 0; i < edges.size(); i++)//构造图与入度数组:无向图,两个点都要处理
	{
		graph[edges[i][0]].push_back(edges[i][1]);
		graph[edges[i][1]].push_back(edges[i][0]);
		indegree[edges[i][0]]++;
		indegree[edges[i][1]]++;
	}
	queue<int> myqueue;//装载入度为1的queue
	for (int i = 0; i < n; i++)
	{
		if (indegree[i] == 1)
			myqueue.push(i);
	}
	int cnt = myqueue.size();//!!令cnt等于myqueue.size(),一次性将入度为1的点全部删去。
	while (n>2)
	{
		n -= cnt;//一次性将入度为一的点全部删去!!不能一个一个删!
		while (cnt--)
		{
			int temp = myqueue.front();
			myqueue.pop();
			indegree[temp] = 0;
			//更新temp的邻接点:若temp临接点的入度为1,则将其放入queue中。
			for (int i = 0; i < graph[temp].size(); i++)
			{
				if (indegree[graph[temp][i]] != 0)
				{
					indegree[graph[temp][i]]--;
					if (indegree[graph[temp][i]] == 1)//放在这里做!只判断邻接点。
						myqueue.push(graph[temp][i]);
				}
				
			}
		}
		cnt = myqueue.size();
	}

	while (!myqueue.empty())
	{
		result.push_back(myqueue.front());
		myqueue.pop();
	}
	return result;
}
};

2.1.1 该题的设计思路

1.删除入度为1的点
有向图的拓扑序列时,我们删除的是前驱为0的节点。

而对于无向图,由于无向图是双向,入度为1即可说明该点就是**图的边缘点**
2.关于一次性删除的问题

当我们按照有向图的拓扑序列一个个删除点并同时判断是否入队时

而当我们采用我们一次性删除的思路时;

解释说明:

- 由题意可知,根据几何想象,这其实就是一个图不断缩小的过程,即**不断地把边缘顶点删除,最终得到中间的根节点的过程**

- 对于该无向图来理解,当我们不断删减边缘点时,也在不断改变图,改变顶点入度,所以**每删除一个点,图的中心节点也可能发生了变化**

- 因此控制一次性删除,我们其实可以理解成,**一圈圈删减,这才叫缩小,所有方向的边缘点都同时删除,才能达到中心节点不偏移**

2.1.2 该题的伪代码

2.1.3 运行结果

示例1:

示例2:

2.1.4分析该题目解题优势及难点。

  • 题目难点:其实一开始看该题目的时候,毫无思路,感觉要获得图中心节点,用遍历什么的都很难想到什么思路,所以我觉得该题难点就是思路难。

  • 解题优势:正是因为对题目思路毫无头绪,所以对该题的解题思路感到很新奇-拓扑序列的变式
    从有向无环图的拓扑序列,延展到无向图。
    虽然主要目的并不是为了得到无向图的该序列,但也是按照该思路的过程,不断删除点缩图。

  • 该思路无向图的拓扑,将各顶点都遍历了一遍,所以时间复杂度应为O(n).

  • 但是同样无向图的该拓扑方式前提同样也是无环路,而题目给的样例也符合该条件:本题名为最小高度树

2.2题目及解题代码

题目:网络延迟时间

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        const int INF = 0x3f3f3f3f;
        vector<int> dist(N+1, INF); // 保存到起点的距离
        vector<bool> st(N+1, false); // 是否最短
        typedef pair<int, int> PII;
        unordered_map<int, vector<PII>> edges; // 邻接表

        queue<int> q;
        q.push(K);
        dist[K] = 0;
        st[K] = true; // 是否在队列中

        for (auto &t: times){
            edges[t[0]].push_back({t[1], t[2]});
        }

        while (!q.empty()){ // 当没有点可以更新的时候,说明得到最短路
            auto t = q.front();
            q.pop();
            st[t] = false;
            for (auto &e: edges[t]){ // 更新队列中的点出发的 所有边
                int v = e.first, w = e.second;
                if (dist[v] > dist[t] + w){
                    dist[v] = dist[t] + w;
                    if (!st[v]){
                        q.push(v);
                        st[v] = true;
                    }
                }
            }
        }
        int ans = *max_element(dist.begin()+1, dist.end());
        return ans == INF ? -1: ans;
    }
};

2.2.1设计思路

  • 这道题其实就是求出点到各顶点的最短路径,求出点K到其他各点的最短距离后,再找出其中的最大距离

  • 在题解中,关于最短路径解法有DisjKstra,Floyd,SPFA。由此对SPFA该种算法进行学习:

SPFA算法实现方法:

- 建立一个队列,初始时队列里只有起始点

- 在建立一个表格记录起始点到所有点的最短路径(该表格的初始值要赋为极大值,该点到他本身的路径赋为0)。

- 然后执行松弛操作(更新数据),用队列里有的点去刷新起始点到所有点的最短路,**如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。**

2.2.2伪代码

SPFA算法

2.2.3运行结果

2.2.4题目难点及解题优势

  • 题目难点:一个就是对题目的理解。
    网络信号需要多久才能使所有节点都收到信息,到达每一个顶点时间应当都是以到该点的最短路径来记
    而使所有节点都能接收到信息,则是所有顶点中,最晚收到,即该点的最短路径最长的。

  • 算法优点:
    通常可用于求含负权边的单源最短路径(DisjKstra权重是一定不能为负的)
    以及判负权环(如果一个点进入队列达到n次,则表明图中存在负环,没有最短路径。)

  • SPFA算法期望的时间复杂度:O(ke), 其中k为所有顶点进队的平均次数,可以证明k一般小于等于2。

2.3题目及解题代码

题目

解题代码

class Solution {
public:
    int findTheCity(int n, vector <vector<int>> &edges, int distanceThreshold) {
        // 定义二维D向量,并初始化各个城市间距离为INT_MAX(无穷)
        vector <vector<int>> D(n, vector<int>(n, INT_MAX));
        // 根据edges[][]初始化D[][]
        for (auto &e : edges) {
            // 无向图两个城市间的两个方向距离相同
            D[e[0]][e[1]] = e[2];
            D[e[1]][e[0]] = e[2];
        }
        // Floyd算法
        for (int k = 0; k < n; k++) {
            // n个顶点依次作为插入点
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (i == j || D[i][k] == INT_MAX || D[k][j] == INT_MAX) {
                        // 这些情况都不符合下一行的if条件,
                        // 单独拿出来只是为了防止两个INT_MAX相加导致溢出
                        continue;
                    }
                    D[i][j] = min(D[i][k] + D[k][j], D[i][j]);
                }
            }
        }
        // 选择出能到达其它城市最少的城市ret
        int ret;
        int minNum = INT_MAX;
        for (int i = 0; i < n; i++) {
            int cnt = 0;
            for (int j = 0; j < n; j++) {
                if (i != j && D[i][j] <= distanceThreshold) {
                    cnt++;
                }
            }
            if (cnt <= minNum) {
                minNum = cnt;
                ret = i;
            }
        }
        return ret;
    }
};


2.3.1设计思路

  • 该题其实还是对最短路径的应用,之所以采用floyd算法,是因为将各个城市间最短路径存在矩阵中,这样存储数据更加方便比较

  • 之后利用矩阵中的数据进行比较,求出各个城市的邻城市即可,就可以找到最少的城市

2.3.2伪代码

2.3.3运行结果

示例1:


示例2:

2.3.4题目难点及解题优势

  • 该题解题思路较简单,通过Floyd算法就可得到各个城市间的最短距离,统计一下即可得到各个城市在规定范围的城市数。

  • Floyd算法,一层循环控制每个点的选入,另外两层循环控制矩阵的更新,因此三层循环时间复杂度O(n^3)

  • 不过忽然想到,要获取顶点在一定距离范围内的邻居点,其实就有点像PTA上的六度空间那道题目。

    六度空间是求各点距离不超过6的点所占总点百分比。我当时写的是用广度遍历。
    不过区别貌似在于,六度空间顶点间的边不带距离值,所以用广度也不算太麻烦,所以如果用Floyd算法解六度空间应该也是完全可以的,但边带值的这题使用广度遍历可能一些操作上还是有点麻烦

posted @ 2020-05-05 21:00  郑梦露  阅读(337)  评论(0编辑  收藏  举报