DS博客作业04--图
0.PTA得分截图
图题目集总得分，请截图，截图中必须有自己名字。题目至少完成总题数的2/3，否则本次作业最高分5分。没有全部做完扣1分。
1.本周学习总结（0-5分）
1.1 总结图内容
1.1.1图存储结构，遍历以及运用
之前的章节我们已经开始接触到非线性结构--树，树表示的是一对多的关系，这篇博客我们要开始了解多对多的结构--图。图形结构是最普遍的一类数据结构，具有广泛的实际应用。比如说我们生活中常见的知识图谱，专业知识的路由路径搜索，解决诸多问题，图形结构是生活中不可缺少的一种结构。
（1）图的定义
- 图：指顶点集 V 和顶点间的关系：边集合E组成的数据结构。图的逻辑结构描述：Graph = (V , E)，其中V表示图包含的顶点的集合，E表示定点与定点之间的关系的集合。
- 有向图和无向图
- 有向图：顾名思义，图有方向，换言之，顶点与顶点之间的边是有方向的，即带有箭头，可以从中知道是从那个点指向那个点的。比如下图就是有向图。
明显可以看出顶点之间的指向关系。 - 无向图：没有方向边。顶点之间只要连接就是互通的。如图：
（2）图的基本术语
- 端点和邻接点
- 无向图:若存在一条边<i，j>，则称顶点i和顶点j互为邻接点。
- 有向图:存在一条边<i，j>，可知i，就之间有一条边，i点指向j点，则称此边是顶点i的一条出边，同时也是顶点j的一条入边；称顶点i 和顶点j 互为邻接点。
- 顶点的度、入度和出度
- 无向图：以顶点i为端点的边数称为该顶点的度。
- 有向图：以顶点i为终点的入边的数目，称为该顶点的入度。以顶点i为始点的出边的数目，称为该顶点的出度。一个顶点的入度与出度的和为该顶点的度。实际上也就是该点连接的边的条数。
- 边与顶点的关系：若一个图中有n个顶点和e条边，每个顶点的度为di（0≤i≤n-1），则有：e=0.5(d1+d2+d3+...+dn-1),即边的数量是各个顶点度的和的二分之一。
- 完全图：一个图中各个顶点都是互通的，我们称这样的图为完全图。
- 无向图：每两个顶点之间都存在着一条边，称为完全无向图， 包含有n*(n-1)/2条边。
- 有向图：每两个顶点之间都存在着方向相反的两条边，称为完全有向图，包含有n*(n-1)条边。
- 稠密图，稀疏图：当一个图接近完全图时，则称为稠密图。相反，当一个图含有较少的边数时，则称为稀疏图。
- 子图：顾名思义，一个图可以从另一个图拆分出来，并且不改变顶点直接的关系，这样的图成为原图的子图，子图是相对于原图来讲的。
- 路径以及路径长度：从一个顶点到另一个顶点所要经过的边叫做路径，经过边的数目之和叫做路径长度。
- 回路以及环：从一个点出发，经过了很多条路径又回到的原来的点，这条路径就是回路，又叫环。
- 连通图连通分量
- 连通图：若图中任意两个顶点都连通，否则称为非连通图。这里的连通并不止指单纯的直接连通，通过几个顶点，还能连在一起就叫做连通。
- 连通分量：在一个非连通图中，找出连通子图，这些子图之间是相互独立的，所以叫做连通分量。一般无向图中不会有连通分量。
- 无向图中，若从顶点i到顶点j有路径，则称顶点i和j是连通的。
- 有向图中若任意两个顶点之间都连通，则称此有向图为强连通图。否则，其各个强连通子图称作它的强连通分量。
- 如何寻找非强连通图中的强连通分量
- 在图中找一个有向的环
- 将其他的顶点与该环的边关系还原，如果加入了这个顶点之后，该环还是一个有向环(我的理解是环上能通到该点，该点也能返回环上)，就形成新的环，依次判断每一个顶点，如果发现有的点能到了环但是无法返回，或者可以返回无法到了，就是这个图的一个强连通分量。
（3）图的存储结构
- 邻接矩阵
实际上就是一个二维数组，x,y 分别表示各个顶点，形成一个二维数组，其中保存的是边与边之间的信息，比如权值。如果两点之间没有连接，需要看i是否等于j,如果不等于，该位置值为无穷，等于的话值为0；
//图的邻接矩阵的存储类型
#define MAXV <最大顶点个数>
typedef struct
{ int no; //顶点编号
InfoType info; //顶点其他信息
} VertexType;
typedef struct //图的定义
{ int edges[MAXV][MAXV]; //邻接矩阵
int n，e; //顶点数，边数
VertexType vexs[MAXV]; //存放顶点信息
} MatGraph;
通常情况下，无向图的邻接链表是延对角线对称的，对角线上所有的位置值是0.有向图一般不会出现这样的情况。邻接矩阵的存储空间为O（n^2）,一个图的邻接矩阵是唯一的，邻接矩阵适合于稠密图的存储。
- 邻接表
将各个顶点放在一个一维数组中，对图中每个顶点i建立一个单链表，将顶点i的所有邻接点链起来。就形成了邻接表。图的邻接表存储方法是一种顺序分配与链式分配相结合的存储方法。
//图的邻接表存储类型定义
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;
（4）图的创建
图是比较抽象的概念，建立图的结构并不是我们看见的图那样存在，他只是以邻接矩阵邻接表行书存在的数据而已。现在以邻接表建立为例。
void CreateAdj(AdjGraph *&G,int n,int e) //创建图邻接表
{
int i,j,a,b;
ArcNode *p;
G=new AdjGraph;
for (i=0;i<n;i++) G->adjlist[i].firstarc=NULL;//给邻接表中所有头结点的指针域置初值
for (i=1;i<=e;i++) //根据输入边建图
{ cin>>a>>b;
p=new ArcNode; //创建一个结点p
p->adjvex=b; //存放邻接点
p->nextarc=G->adjlist[a].firstarc; //采用头插法插入结点p
G->adjlist[a].firstarc=p;
}
G->n=n; G->e=n;
}
该种方法只能建立无向图，如果想建立有向图的话需要在对a对b赋值的时候进行b对a赋值。
（5）图的遍历
- 图的遍历:和树的遍历差不多，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次。这样的过程叫做图的遍历。在这里我们主要学习两种遍历方式，深度优先遍历（DFS）和广度优先遍历（BFS）。
<1>深度优先遍历 - 遍历过程如下：
- 1.从图中某个初始顶点v出发，首先访问初始顶点v。
- 2.选择一个与顶点v相邻且没被访问过的顶点w为初始顶点，再从w出发进行深度优先搜索，直到图中与当前顶点v邻接的所有顶点都被访问过为止。
就像它的名字一样，深度优先，就是不管路径是如何的。找到一条道路，使得整个图的顶点都被遍历过，这样的遍历方式就是深度优先遍历。
//对邻接表进行深度优先遍历
void DFS(ALGraph *G,int v)
{ ArcNode *p;
visited[v]=1; //置已访问标记
printf("%d ",v);
p=G->adjlist[v].firstarc;
while (p!=NULL)
{
if (visited[p->adjvex]==0) DFS(G,p->adjvex);
p=p->nextarc;
}
}
<2>广度优先遍历
- 遍历过程如下：
- 访问初始点v，接着访问v的所有未被访问过的邻接点。
- 按照次序访问每一个顶点的所有未被访问过的邻接点。
- 依次类推，直到图中所有顶点都被访问过为止。
广度优先遍历有点类似于树的层次遍历，写代码的时候需要借助队列或者栈这样的结构，来保存每一层的数据。
//采用广度优先遍历方法遍历非连通图的算法如下：
void BFS1(AdjGraph *G)
{ int i;
for (i=0;i<G->n;i++) //遍历所有未访问过的顶点
if (visited[i]==0)
BFS(G，i);
}
（6）判断图是否连通
有这样的一个问题，假如图G采用邻接表存储，设计一个算法，判断无向图G是否是联通的。该怎么做呢？求解思路如下：
- 用深度优先遍历方法，先给visited[]数组（为全局变量）置初值0，然后从0顶点开始遍历该图。
- 在一次遍历之后，若所有顶点i的visited[i]均为1，则该图是连通的；否则不连通。
//判断无向图是否连通代码:
int visited[MAXV];
bool Connect(AdjGraph *G) //判断无向图G的连通性
{ int i;
bool flag=true;
for (i=0;i<G->n;i++) //visited数组置初值
visited[i]=0;
DFS(G，0); //调用前面的中DSF算法，从顶点0开始深度优先遍历
for (i=0;i<G->n;i++)
if (visited[i]==0)
{ flag=false;
break;
}
return flag;
}
(6)简单路径问题
- <1>判断两个顶点之间是否存在简单路径
我们考虑的是是否能找到简单路径，所以要使用深度优先遍历，不在乎找到的路径是什么样子的，找到就行。
void ExistPath(AGraph *G，int u，int v，bool &has)
{ //has表示u到v是否有路径,初值为false
int w; ArcNode *p;
visited[u]=1; //置已访问标记
if (u==v) //找到了一条路径
{ has=true; //置has为true并结束算法
return;
}
p=G->adjlist[u].firstarc; //p指向顶点u的第一个相邻点
while (p!=NULL)
{ w=p->adjvex; //w为顶点u的相邻顶点
if (visited[w]==0) //若w顶点未访问,递归访问它
ExistPath(G，w，v，has);
p=p->nextarc; //p指向顶点u的下一个相邻点
}
- <2>求最短路径
假设图G采用邻接表存储，设计一个算法：求不带权无向连通图G中从顶点uv的一条最短路径（路径上经过的顶点数最少）。该使用那种遍历方式呢？这让我想到了之前的迷宫问题。广度优先遍历可以帮助找到最短的路径。广度优先遍历找到的路径一定是最短路径，而深度优先遍历则不一定。深度优先遍历能找所有路径，而广度优先遍历难以实现
void ShortPath(AdjGraph *G,int u,int v)
{ //输出从顶点u到顶点v的最短逆路径
qu[rear].data=u;//第一个顶点u进队
while (front!=rear)//队不空循环
{ front++; //出队顶点w
w=qu[front].data;
if (w==v) 根据parent关系输出路径break;
while(遍历邻接表)
{ rear++;//将w的未访问过的邻接点进队
qu[rear].data=p->adjvex;
qu[rear].parent=front;
}
}
}
1.1.2最小生成树
首先我们要了解一个概念，什么是生成树？什么是最小生成树？对于数据来说，图存储结构是不好对其进行操作的，然而将一个图变成我们熟悉的树，就方便了对数据的操作。一个连通图的生成树是一个极小连通子图，它含有图中全部n个顶点和构成一棵树的(n-1)条边。生成树是不能有回路的。如果在一颗生成树上添加一条边，那么必定构成一个环。由深度优先遍历得到的生成树称为深度优先生成树。由广度优先遍历得到的生成树称为广度优先生成树。一个图由于它的遍历方式不相同，生成的图也是不一样的，生成树有大有小。那么，对于带权连通图G来说，他有n个顶点，n-1条边。每一条边带有权值，其中权值之和最小的生成树称为图的最小生成树。如何构建最小生成树呢？
（1）普利姆算法
和之前一样，先来看看普利姆算法思路的难懂版解释是什么样子的。
- （1）初始化U={v}。v到其他顶点的所有边为候选边；
- （2）重复以下步骤n-1次，使得其他n-1个顶点被加入到U中：
- 从候选边中挑选权值最小的边输出，设该边在V-U中的顶点是k，将k加入U中；
- 考察当前V-U中的所有顶点j，修改候选边：若(j，k)的权值小于原来和顶点k关联的候选边，则用(k，j)取代后者作为候选边。
是不是看完之后似懂非懂红红火火恍恍惚惚？如何理解这个算法呢？其实很简单。总结一下：
- 首先选一个起始点放入集合U中，在与这个起始点相连接的邻接点中，选一个连边权值最小的点，加入到这个集合来。然后这两个点就形成了一个整体。
- 再在连接这个整体的所有点中，选权值最小的（离这个整体最近的点，注意，不是离单个点最近的点，而是距离整体最近的点），然后加入集合U，重复这一个步骤，知道所有的点都放进去这个集合U中。就生成了树，且是最小生成树。
//普利姆算法如下：
#define INF 32767 //INF表示∞
void Prim(MGraph g,int v)
{ int lowcost[MAXV],min,closest[MAXV],i,j,k;
for (i=0;i<g.n;i++) //给lowcost[]和closest[]置初值
{ lowcost[i]=g.edges[v][i];closest[i]=v;}
for (i=1;i<g.n;i++) //找出(n-1)个顶点
{ min=INF;
for (j=0;j<g.n;j++) // 在(V-U)中找出离U最近的顶点k
if (lowcost[j]!=0 && lowcost[j]<min)
{ min=lowcost[j]; k=j; /k记录最近顶点的编号}
printf(" 边(%d,%d)权为:%d\n",closest[k],k,min);
lowcost[k]=0; //标记k已经加入U
for (j=0;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;
}
}
}
（2）克鲁斯卡尔算法
克鲁斯卡尔（Kruskal）算法也是一种求带权无向图的最小生成树的构造性算法。先来看看他的算法过程：
- 置U的初值等于V（即包含有G中的全部顶点），TE的初值为空集（即图T中每一个顶点都构成一个连通分量）。
- 将图G中的边按权值从小到大的顺序依次选取：
- 若选取的边未使生成树T形成回路，则加入TE；
- 否则舍弃，直到TE中包含(n-1)条边为止。
克鲁斯卡尔算法的思路有点像贪心算法吧（个人觉得），主要思路也是不难理解的，将边抹去，有条件的加入边，使得生成的树为最小生成树。
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++; //扫描下一条边
}
}
1.1.3最短路径
在生活中，有时候我们会为选择的问题发愁，比如出去玩的时候，要到达某个地点，就回面临选择那条道路的问题。每个人都想又快又近的到达终点，所以，这涉及到最短路径的问题。如何求最短路径呢？这里有两种算法。分别解决单源最短路径问题和所有顶点最短路径问题。
（1）迪杰斯特拉算法
算法思路：
- a.初始化两个集合S（代表入选的顶点的集合），T（表示未选中的点的集合）
- b.在T中选取一个其距离值最小的顶点W加入S，加入之后，比较加入的点对点与点之间距离是否有改变。如果有要进行值的修改，没有则继续。重复上述步骤。
这就是迪杰斯特拉算法的大致思路，那么，转化为代码层面上来说，如何存放每个点的最短路径，如何存放最短路径长度呢？这里应用了dist[],path[]两个数组的帮助。其中 - dist[]数组存最短路径长度。
- path[]数组存最短路径。每一个path存的是前一个点，这样从后向前退就能的到完整的路径。
//迪杰斯特拉算法代码：
void Dijkstra(MatGraph g，int v)
{ int dist[MAXV]，path[MAXV];
int s[MAXV];
int mindis,i,j,u;
for (i=0;i<g.n;i++)
{ dist[i]=g.edges[v][i]; //距离初始化
s[i]=0; //s[]置空
if (g.edges[v][i]<INF) //路径初始化
path[i]=v; //顶点v到i有边时
else
path[i]=-1; //顶点v到i没边时
}
s[v]=1;
for (i=0;i<g.n;i++) //循环n-1次
{ mindis=INF;
for (j=0;j<g.n;j++)
if (s[j]==0 && dist[j]<mindis)
{ u=j;
mindis=dist[j];
}
s[u]=1; //顶点u加入S中
for (j=0;j<g.n;j++) //修改不在s中的顶点的距离
if (s[j]==0)
if (g.edges[u][j]<INF &&dist[u]+g.edges[u][j]<dist[j])
{ dist[j]=dist[u]+g.edges[u][j];
path[j]=u;
}
}
Dispath(dist,path,s,g.n,v); //输出最短路径
}
（2）弗洛伊德算法
迪杰斯特拉算法好是好，但是只能解决一个点到图中其他点之间的最短路径，但是如果想知道图中每个点之间的最短路径分别是什么该怎做呢？用什么方式更加直观？有的人可能会说，既然迪杰斯特拉算法能求一个点的，多求几次，不就知道了所有点的最短路径了吗？可以这样做，不过代码量稍微大了点，这里我们引入新的算法，佛洛依德算法。
算法思路：从邻接矩阵a开始进行n次迭代，第一次迭代后a[i,j]的值是从vi到vj且中间不经过变化大于1的顶点的最短路径长度；第k次迭代后a[i,j]的值是从vi到vj且中间不经过变化大于k的顶点的最短路径长度 第n次迭代后a[i,j]的值就是从vi到vj的最短路径长度。
算法描述：
- (1) 用数组d[i][j]来记录i,j之间的最短距离。初始化d[i][j],若i=j则d[i][j]=0,
若i,j之间有边连接则d[i][j]的值为该边的权值，否则d[i][j]的值为max 。 - (2) 对所有的k值从1到n，修正任意两点之间的最短距离，计算d[i][k]+d[k][j]的值，
若小于d[i][j],则d[i][j]= d[i][k]+d[k][j]，否则d[i][j]的值不变。
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
}
}
}
1.1.4拓扑排序、关键路径
什么是拓朴排序呢？在生活我们会遇见做很多事情，那么先做什么事情，什么事情做完之后再做什么比较省时间，于此同时可以做其他什么事情，等。拓朴排序就是在一个有向图中找一个拓扑序列的过程称。该序列必须满足条件：
- 每个顶点出现且只出现一次。
- 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。
那么怎么进行拓朴排序呢？步骤如下： - 1.从有向图中选取一个没有前驱的顶点，并输出之（当然没有前驱的结点肯定不是一个，所以输出的结果也是多种多样的）；
- 2.从有向图中删去此顶点以及所有以它为尾的弧，然后继续进行寻找；
- 3.重复上述两步，直至图空，或者图不空但找不到无前驱的顶点为止。
//结构体定义：
typedef struct //表头节点类型
{ vertex data; //顶点信息
int count; //存放顶点入度
ArcNode *firstarc; //指向第一条弧
} VNode;
//拓朴排序代码：
void TopSort(AdjGraph *G) //拓扑排序算法
{ int i，j;
int St[MAXV]，top=-1; //栈St的指针为top
ArcNode *p;
for (i=0;i<G->n;i++) //入度置初值0
G->adjlist[i].count=0;
for (i=0;i<G->n;i++) //求所有顶点的入度
{ p=G->adjlist[i].firstarc;
while (p!=NULL)
{ G->adjlist[p->adjvex].count++;
p=p->nextarc;
}
}
for (i=0;i<G->n;i++) //将入度为0的顶点进栈
if (G->adjlist[i].count==0)
{ top++;
St[top]=i;
}
while (top>-1) //栈不空循环
{ i=St[top];top--; //出栈一个顶点i
printf("%d ",i); //输出该顶点
p=G->adjlist[i].firstarc; //找第一个邻接点
while (p!=NULL) //将顶点i的出边邻接点的入度减1
{ j=p->adjvex;
G->adjlist[j].count--;
if (G->adjlist[j].count==0) //将入度为0的邻接点进栈
{ top++;
St[top]=j;
}
p=p->nextarc; //找下一个邻接点
}
}
}
（1）事件的最早开始和最迟开始时间以及求法。
事件v最早开始时间ve(v)：v作为源点事件最早开始时间为0。当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}。求最迟开始时间就是需要逆推。
（2）求关键路径的过程：
- 1.对有向图拓扑排序
- 2.根据拓扑序列计算事件(顶点)的ve，vl数组
ve(j) = Max{ve(i) + dut(<i,j>)}
vl(i) = Min - 3.计算关键活动的e[],l[]。即边的最早、最迟时间
e(i) = ve(j)
l(i) = vl(k) - dut(<j, k> - 4.找e=l边即为关键活动
- 5.关键活动连接起来就是关键路径
1.2.谈谈你对图的认识及学习体会。
对图的学习已经过了两周左右，刚开始老师介绍图的时候说这一部分的内容比较简单，但是我并没有这样觉得。这一部分中我学会了很多的算法，比如求最小生成树的prim算法，克鲁斯卡尔算法，还有什么狄克斯特拉算法等等，刚开始的时候看见这些算法觉得十分高级，对于算法的解释也十分高级，高级的让我读不懂。每一次预习课件总是先看一下课件中的解释，然后进行百度，看别人的博客来理解，学习。图的知识点比较综合，包含有许多之前的知识，比如树的应用，栈和队列的应用。学习本部分知识也是复习了之前学过的内容。感觉这部分拉下的有一点多了，很多的知识没有上手进行编码所以有一点生疏。
2.阅读代码（0--5分）
2.1 题目及解题代码
TreeNode* ans;
bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
if (root == nullptr) return false;
bool lson = dfs(root->left, p, q);
bool rson = dfs(root->right, p, q);
if ((lson && rson) || ((root->val == p->val || root->val == q->val) && (lson || rson))) {
ans = root;
}
return lson || rson || (root->val == p->val || root->val == q->val);
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
dfs(root, p, q);
return ans;
}
2.1.1 该题的设计思路
递归遍历整棵二叉树，定义 fx 表示 x 节点的子树中是否包含 p 节点或 q 节点，如果包含为 true，否则为 false。那么符合条件的最近公共祖先 x 一定满足如下条件：
(flson && frson) ∣∣ ((x = p ∣∣ x = q) && (flson ∣∣ frson))其中 lson 和 rson 分别代表 x 节点的左孩子和右孩子。
（1）flson && frson 说明左子树和右子树均包含 p 节点或 q 节点，如果左子树包含的是 p 节点，那么右子树只能包含 q 节点，反之亦然，因为 p 节点和 q 节点都是不同且唯一的节点，因此如果满足这个判断条件即可说明 x 就是我们要找的最近公共祖先；
（2）再来看第二条判断条件，这个判断条件即是考虑了 x 恰好是 p 节点或 q 节点且它的左子树或右子树有一个包含了另一个节点的情况，因此如果满足这个判断条件亦可说明 x 就是我们要找的最近公共祖先。
- 时间复杂度：O(N)，其中 N 是二叉树的节点数。二叉树的所有节点有且只会被访问一次，因此时间复杂度为 O(N)。
- 空间复杂度：O(N)，其中 N 是二叉树的节点数。递归调用的栈深度取决于二叉树的高度，二叉树最坏情况下为一条链，此时高度为 N，因此空间复杂度为 O(N)。
2.1.2 该题的伪代码
文字+代码简要介绍本题思路
bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
如果根节点为NULL 返回flase;
lson = dfs(root->left, p, q);
rson = dfs(root->right, p, q);
如果一个节点左右孩子均包含或者x 恰好是 p 节点或 q 节点且它的左子树或右子树有一个包含了另一个节点
{
找到了最近祖先结点；
}
return lson || rson || (root->val == p->val || root->val == q->val);
}
2.1.3 运行结果
网上题解给的答案不一定能跑，请把代码复制自己运行完成，并截图。
2.1.4分析该题目解题优势及难点。
1.优势；通过一个判断语句同时考虑了两种情况，思想比较好，大大节约了代码量；
2.难点：那条判断语句不容易想明白，递归算法如果写错的话也不好找问题在哪里。
2.2 题目及解题代码
可截图，或复制代码，需要用代码符号渲染。题目截图后一定要清晰。
int trap(vector<int>& height)
{
int ans = 0;
int size = height.size();
for (int i = 1; i < size - 1; i++) {
int max_left = 0, max_right = 0;
for (int j = i; j >= 0; j--) { //Search the left part for max bar size
max_left = max(max_left, height[j]);
}
for (int j = i; j < size; j++) { //Search the right part for max bar size
max_right = max(max_right, height[j]);
}
ans += min(max_left, max_right) - height[i];
}
return ans;
}
2.2.1 该题的设计思路
暴力破解法：直接按问题描述进行。对于数组中的每个元素，我们找出下雨后水能达到的最高位置，等于两边最大高度的较小值减去当前高度的值。
- 时间复杂度： O(n^2)数组中的每个元素都需要向左向右扫描。
- 空间复杂度 O(1) 的额外空间。
2.2.2 该题的伪代码
文字+代码简要介绍本题思路
初始化 ans=0
从左向右扫描数组：
初始化 max_left=0和 max_right=0
从当前元素向左扫描并更新：
ax_left=max(max_left,height[j])
从当前元素向右扫描并更新：
max_right=max(max_right,height[j])
将min(max_left,max_right)−height[i]） 累加到 ans
2.2.3 运行结果
网上题解给的答案不一定能跑，请把代码复制自己运行完成，并截图。
2.2.4分析该题目解题优势及难点。
1.优点：暴力破解法比较直接，代码易懂；
2.缺点：面临的问题就是不太高效，没有其他方法节约时间空间；
2.3 题目及解题代码
可截图，或复制代码，需要用代码符号渲染。题目截图后一定要清晰。
int largestRectangleArea(vector<int>& heights)
{
int ans = 0;
vector<int> st;
heights.insert(heights.begin(), 0);
heights.push_back(0);
for (int i = 0; i < heights.size(); i++)
{
while (!st.empty() && heights[st.back()] > heights[i])
{
int cur = st.back();
st.pop_back();
int left = st.back() + 1;
int right = i - 1;
ans = max(ans, (right - left + 1) * heights[cur]);
}
st.push_back(i);
}
return ans;
}
2.3.1 该题的设计思路
链表题目，请用图形方式展示解决方法。同时分析该题的算法时间复杂度和空间复杂度。
1.对于一个高度，如果能得到向左和向右的边界
2.那么就能对每个高度求一次面积
3.遍历所有高度，即可得出最大面积
4.使用单调栈，在出栈操作时得到前后边界并计算面积
2.3.2 该题的伪代码
文字+代码简要介绍本题思路
int largestRectangleArea(vector<int>& heights)
{
定义整形变量ans = 0;
定义vector<int> st;
heights.insert(heights.begin(), 0);
heights.push_back(0);
遍历所有矩形高度
{
while (!st.empty() && heights[st.back()] > heights[i])
{
取栈顶元素
出栈;
计算left,right值；
ans = max(ans, (right - left + 1) * heights[cur]);
}
将i入栈;
}
return ans;
}
2.3.3 运行结果
网上题解给的答案不一定能跑，请把代码复制自己运行完成，并截图。
2.3.4分析该题目解题优势及难点。
1.优势：该代码思路比较好，容易理解，代码量少；
2.难点：自己想不一定能想出来，尤其是利用单调栈的做法；
