DS博客作业04--图

0.PTA得分截图

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

1.1 总结图内容

一、图的基本概念

1.定义和基本术语

定义:顶点集 V 和顶点间的关系:边集合E组成的数据结构。

类别:
<1>有向图:由顶点集和弧集构成的图
<2>无向图:没方向边

基本术语:

<1>端点和邻接点

无向图:若存在一条边(i,j),则称顶点i和顶点j互为邻接点。

有向图:存在一条边<i,j>,则称此边是顶点i的一条出边,同时也是顶点j的一条入边;称顶点i 和顶点j 互为邻接点。

<2>顶点的度、入度和出度

无向图:以顶点i为端点的边数称为该顶点的度。   

有向图:以顶点i为终点的入边的数目,称为该顶点的入度。以顶点i为始点的出边的数目,称为该顶点的出度。一个顶点的入度与出度的和为该顶点的度。 
    
<3>完全图

无向图:每两个顶点之间都存在着一条边,称为完全无向图, 包含有n(n-1)/2条边。

有向图:每两个顶点之间都存在着方向相反的两条边,称为完全有向图,包含有n(n-1)条边。

<4>稠密图、稀疏图

当一个图接近完全图时,则称为稠密图。

相反,当一个图含有较少的边数(即当e<<n(n-1))时,则称为稀疏图。
 
<5>子图

设有两个图G=(V,E)和G'=(V',E'),若V'是V的子集,即V'属于V,且E'是E的子集,即E'属于E,则称G'是G的子图。

<6>路径和路径长度

路径长度是指一条路径上经过的边的数目

简单路径:一条路径上除开始点和结束点可以相同外,其余顶点均不相同

<7>回路或环

回路或环:一条路径上的开始点与结束点为同一个顶点。

简单回路或简单环:开始点与结束点相同的简单路径。

<8>连通、连通图和连通分量

无向图:若从顶点i到顶点j有路径,则称顶点i和j是连通的。   
 
连通图:若图中任意两个顶点都连通,否则称为非连通图。

连通分量:无向图G中的极大连通子图。
* 任何连通图的连通分量只有一个,即本身
* 而非连通图有多个连通分量。

有向图:
* 若任意两个顶点之间都存在一条有向路径,则称此有向图为强连通图。
* 否则,其各个强连通子图称作它的强连通分量。

<9>权和网  

图中每一条边都可以附有一个对应的数值,这种与边相关的数值称为权。

边上带有权的图称为带权图,也称作网。

2.存储结构和基本运算算法

<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;//声明邻接矩阵存储的图

图像表示:

<2>邻接表

存储表示:

  • 对图中每个顶点i建立一个单链表,将顶点i的所有邻接点链起来。

  • 每个单链表上添加一个表头结点(表示顶点信息)。并将所有表头结点构成一个数组,下标为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;
AdjGraph *G;//声明一个邻接表存储的图G

图像表示:

3.基本运算算法设计

①创建图的运算算法

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;
}

②输出图的运算算法

void DispAdj(AdjGraph *G)	//输出邻接表G
{      int i;
       ArcNode *p;
       for (i=0;i<G->n;i++)
       {    p=G->adjlist[i].firstarc;//访问第一个节点
	    printf("%3d: ",i);
	while (p!=NULL)
	{    printf("%3d[%d]→",p->adjvex,p->weight);
	     p=p->nextarc;
	}
	printf("∧\n");
       }
}

③销毁图的运算算法

void DestroyAdj(AdjGraph *&G)   //销毁邻接表
{    int i; ArcNode *pre,*p;
     for (i=0;i<G->n;i++)		//扫描所有的单链表
     {    pre=G->adjlist[i].firstarc;//p指向第i个单链表的首结点
	  if (pre!=NULL)
	  {    p=pre->nextarc;
	       while (p!=NULL)	//释放第i个单链表的所有边结点
	      {    free(pre);
		   pre=p; p=p->nextarc;
	      }
	      delete pre;
	  }
    }
    delete G;			//释放头结点数组
}

二、图的遍历及应用

1.定义

定义:从给定图中任意指定的顶点(称为初始点)出发,按照某种搜索方法沿着图的边访问图中的所有顶点,使每个顶点仅被访问一次。

类别:深度优先遍历(DFS)。广度优先遍历(BFS)。

2.遍历方法及算法

①DFS

过程:

  • 从图中某个初始顶点v出发,首先访问初始顶点v。

  • 选择一个与顶点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;              	
     }
}

图像表示:

②BFS

过程:

  • 访问初始点v,接着访问v的所有未被访问过的邻接点。

  • 按照次序访问每一个顶点的所有未被访问过的邻接点。
     

  • 依次类推,直到图中所有顶点都被访问过为止。

算法思路:

建一个访问队列q
访问v节点,加入队列q
while(队列不空)
    取队头元素w
    遍历w的邻接表    
         取邻接点j
         若j未被访问,则加入队列q,并访问j。
end while

图像表示:

3.图遍历算法的应用

①判断无向图G是否连通

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;
}

②判断顶点u->v是否有简单路径

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的下一个相邻点
      }
} 

③求不带权无向连通图G中从顶点u->v的一条最短路径

typedef struct
{      int data;	//顶点编号
       int parent;	//前一个顶点的位置
} QUERE;	
	
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.概念

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

  • 对于带权连通图G ,n个顶点,n-1条边

  • 根据深度遍历或广度遍历生成生成树,树不唯一

  • 其中权值之和最小的生成树称为图的最小生成树

2.构造最小生成树算法

①普里姆(Prim)算法

思路过程:

  • 初始化U={v}。v到其他顶点的所有边为候选边;

  • 重复以下步骤n-1次,使得其他n-1个顶点被加入到U中:

    • 从候选边中挑选权值最小的边输出,设该边在V-U中的顶点是k,将k加入U中;
    • 考察当前V-U中的所有顶点j,修改候选边:若(j,k)的权值小于原来和顶点k关联的候选边,则用(k,j)取代后者作为候选边。

辅助数组:

  • closest[i]:最小生成树的边依附在U中顶点编号。
  • lowcost[i]表示顶点i(i ∈ V-U)到U中顶点的边权重,取最小权重的顶点k加入U。并规定lowcost[k]=0表示这个顶点在U中
  • (closest[k],k)构造最小生成树一条边。

算法设计:

#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;
	   } }}

图像表示:

②克鲁斯卡尔(Kruskal)算法

思路过程:

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

辅助结构体

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

算法设计:

void Kruskal(AdjGraph *g)
{     int i,j,u1,v1,sn1,sn2,k;
      int vset[MAXV]; //集合辅助数组
      Edge E[MaxSize];	//存放所有边
      k=0;			//E数组的下标从0开始计
    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;
	}
    }
     Sort(E,g.e);	//用快排对E数组按权值递增排序
     for (i=0;i<g.n;i++) 	//初始化集合
	vset[i]=i;
	k=1;		//k表示当前构造生成树的第几条边,初值为1
	j=0;		//E中边的下标,初值为0
	while (k<g.n)	//生成的顶点数小于n时循环
	{ 
              u1=E[j].u;v1=E[j].v;	//取一条边的头尾顶点
	      sn1=vset[u1];
	      sn2=vset[v1];	//分别得到两个顶点所属的集合编号
 	      if (sn1!=sn2)  	//两顶点属于不同的集合
	      {	printf("  (%d,%d):%d\n",u1,v1,E[j].w);
		k++;		   	//生成边数增1
		for (i=0;i<g.n;i++)  	//两个集合统一编号
		      if (vset[i]==sn2) 	//集合编号为sn2的改为sn1
			vset[i]=sn1;
	      }
	     j++;			   //扫描下一条边
        }
}

图像表示:

3.两种算法的比较

普里姆算法:O(n2)、适用于稠密图

克鲁斯卡尔算法:O(eloge)、适用于稀疏图

实现Prim算法,选择图的邻接矩阵存储结构

实现克鲁斯卡尔算法,选择图的邻接表存储结构

四、最短路径

1.定义

在带权有向图中A点(源点)到达B点(终点)的多条路径中,寻找一条各边权值之和最小的路径,即最短路径。

2.单源最短路径—Dijkstra(迪杰斯特拉)算法

问题描述:

给定一个带权有向图G与源点v,求从v到G中其他顶点的最短路径,并限定各边上的权值大于或等于0。

设计思路:

  • 初始化

  • S={入选顶点集合,初值V0},T={未选顶点集合}。

    • 若存在<V0,Vi>,距离值为<V0,Vi>弧上的权值

    • 若不存在<V0,Vi>,距离值为∞

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

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

  • S中加入顶点w后,对T中顶点的距离值进行修改:

    • 若加进W作中间顶点,从V0到Vj的距离值比不加W的路径要短,则修改此距离值;
  • 重复上述步骤,直到S中包含所有顶点,即S=V为止。

辅助数组:

数组dist[]:源点V0到每个终点的最短路径长度。

数组path[]:最短路径序列的前一顶点的序号;初值或无路径用-1表示

算法展示:

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;	 		//源点v放入S中
       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);	//输出最短路径
}

图像表示:

算法特点:

  • 不适用带负权值的带权图求单源最短路径。

  • 不适用求最长路径长度。

    • 最短路径长度是递增

    • 顶点u加入S后,不会再修改源点v到u的最短路径长度

3.所有顶点间的最短路径—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
            }
   }
}	

图像表示:

五、拓扑排序和关键路径

1.拓扑排列

定义:

在一个有向图中找一个拓扑序列的过程称为拓扑排序。序列必须满足条件:

  • 每个顶点出现且只出现一次。

  • 若存在一条从顶点 A 到顶点 B 的路径,那么在序列中顶点 A 出现在顶点 B 的前面。

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

  • 有向无环图才有拓扑排序,非DAG图没有拓扑排序

设计思路:

  • 从有向图中选取一个没有前驱的顶点,并输出之;

  • 从有向图中删去此顶点以及所有以它为尾的弧;

  • 重复上述两步,直至图空,或者图不空但找不到无前驱的顶点为止。

辅助结构体:

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;		//找下一个邻接点
	}
       }
}

2.关键路径

定义:关键路径为源点到汇点的最长路径。

基本模块:

①事件的最早开始和最迟开始时间

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

ve(v)=0  			当v为初始源点时
ve(v)=MAX{ve(x)+a,ve(y)+b,ve(z)+c}	否则

v为源点事件最早开始时间一定是前驱事件x,y,z已完成。

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

vl(v)=ve(v)			当v为终点时
vl(v)=MIN{vl(x)-a,vl(y)-b,vl(z)-c}	否则

最迟时间要保证后继事件能完成,取最小

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

活动a(边)的最早开始时间e(a)指该活动起点x事件的最早开始时间,即:

e(a)=ve(x)

活动a的最迟开始时间l(a)指该活动终点y事件的最迟开始时间与该活动所需时间之差,即:

l(a)=vl(y)-c

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

关键路径上的活动都是关键活动

设计思路:

  • 对有向图拓扑排序

  • 根据拓扑序列计算事件(顶点)的ve,vl数组

    • ve(j) = Max{ve(i) + dut(<i,j>)}

    • vl(i) = Min{vl(j) - dut(<i,j>)}

  • 计算关键活动的e[],l[]。即边的最早、最迟时间

    • e(i) = ve(j)

    • l(i) = vl(k) - dut(<j, k>)

  • 找e=l边即为关键活动

  • 关键活动连接起来就是关键路径

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

经过数周的学习,我发现图是继顺序结构后略为抽象的一种非顺序结构

正因为图的复杂性,也正好适用于解决很多复杂的问题,在关系越复杂的场景中,就越能体现图结构的优势所在

能够熟练地掌握并在问题中应用图知识,是现阶段的要求,也是学习的目标

图能够很好地适用于生活中的各种场景,例如社交网络关系、路由器的路径搜索、GIS求最短路径的问题等

图即是数据结构较难的一部分,也是最重要的一部分,在学习完图的相关知识后,思维又有了一定的创新和拓展

2.阅读代码(0--5分)

2.1 题目及解题代码

题目

解题代码

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.1.1 该题的设计思路

时间复杂度: O(n^2)

空间复杂度: O(n)

2.1.2 该题的伪代码

int largestRectangleArea(vector<int>& heights)
{
    vector<int> st;
    if(对于一个高度,能得到向左和向右的边界)
        对每个高度求一次面积
    for(遍历所有高度)
    {
        得出最大面积
        使用单调栈
        在出栈操作时得到前后边界并计算面积
    }
    返回ans
}

2.1.3 运行结果

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

解题优势:

使用单调栈。单调栈分为单调递增栈和单调递减栈,单调递增栈即栈内元素保持单调递增的栈,同理单调递减栈即栈内元素保持单调递减的栈。
如果新的元素比栈顶元素大,就入栈,如果新的元素较小,那就一直把栈内元素弹出来,直到栈顶比新元素小。
加入这样一个规则之后, 栈内的元素是递增的。
当元素出栈时,说明这个新元素是出栈元素向后找第一个比其小的元素。
当元素出栈后,说明新栈顶元素是出栈元素向前找第一个比其小的元素。

难点:

如果输入是递增的话,这个代码最后都无法弹出计算面积。需要在Heights数组的后面再加上一个0,这样才可以强迫栈内元素出栈计算面积。

2.2 题目及解题代码

题目

解题代码

class Solution {
public:
    static constexpr int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    static constexpr int MAX_N = 100 + 5;

    struct Coordinate {
        int x, y, step;
    };

    int n, m;
    vector<vector<int>> a;

    bool vis[MAX_N][MAX_N];

    int findNearestLand(int x, int y) {
        memset(vis, 0, sizeof vis);
        queue <Coordinate> q;
        q.push({x, y, 0});
        vis[x][y] = 1;
        while (!q.empty()) {
            auto f = q.front(); q.pop();
            for (int i = 0; i < 4; ++i) {
                int nx = f.x + dx[i], ny = f.y + dy[i];
                if (!(nx >= 0 && nx <= n - 1 && ny >= 0 && ny <= m - 1)) continue;
                if (!vis[nx][ny]) {
                    q.push({nx, ny, f.step + 1});
                    vis[nx][ny] = 1;
                    if (a[nx][ny]) return f.step + 1;
                }
            }
        }
        return -1;
    }
    
    int maxDistance(vector<vector<int>>& grid) {
        this->n = grid.size();
        this->m = grid.at(0).size();
        a = grid;
        int ans = -1;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (!a[i][j]) {
                    ans = max(ans, findNearestLand(i, j));
                }
            }
        }
        return ans;
    }
};

2.2.1 该题的设计思路

时间复杂度: O(n^4)

空间复杂度: O(n^2)

2.2.2 该题的伪代码

int findNearestLand(int x, int y)
{
    把所有的陆地都入队
    从各个陆地开始,一圈一圈的遍历海洋
    最后遍历到的海洋即离陆地最远的海洋
}
int maxDistance(vector<vector<int>>& grid) 
{
    取出队列的元素,将其四周的海洋入队
    没有陆地或者没有海洋,返回-1
    得到最后一次遍历到的海洋的距离
    返回ans
}

2.2.3 运行结果

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

解题优势:

当我们搜索到一个新入队的区域它的grid值为1,
即这个区域是陆地区域的时候我们就可以停止搜索。
BFS能保证当前的这个区域是最近的陆地区域(BFS的性质决定了这里求出来的一定是最短路)。

难点:

考虑最坏情况所有的区域都是海洋,那么每一个区域都会进行BFS对于每一次 BFS。
最坏的情况是找不到陆地区域,我们只能遍历完剩下的 n^2 - 1个海洋区域。
由于 vis 数组确保每个区域只被访问一次,所以单次BFS的渐进时间复杂度是O(n^2),程序的总的渐进时间复杂度较大。

2.3 题目及解题代码

题目:

解题代码:

int trap(vector<int>& height)
{
    int ans = 0, current = 0;
    stack<int> st;
    while (current < height.size()) {
        while (!st.empty() && height[current] > height[st.top()]) {
            int top = st.top();
            st.pop();
            if (st.empty())
                break;
            int distance = current - st.top() - 1;
            int bounded_height = min(height[current], height[st.top()]) - height[top];
            ans += distance * bounded_height;
        }
        st.push(current++);
    }
    return ans;
}

2.3.1 该题的设计思路

时间复杂度: O(n)

空间复杂度: O(n)

2.3.2 该题的伪代码

int trap(vector<int>& height)
{
    使用栈来存储条形块的索引下标。
    遍历数组
    当栈非空且height[current]>height[st.top()]
        意味着栈中元素可以被弹出,弹出栈顶元素top。
        计算当前元素和栈顶元素的距离,准备进行填充操作
            distance=current−st.top()−1
        找出界定高度
            bounded_height=min(height[current],height[st.top()])−height[top]
        往答案中累加积水量
            ans+=distance×bounded_height
    将当前索引下标入栈
    将current移动到下个位置
    返回ans
}

2.3.3 运行结果

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

解题优势:

不用存储最大高度,而是用栈来跟踪可能储水的最长的条形块。使用栈就可以在一次遍历内完成计算。

难点:

在遍历数组时维护一个栈。
如果当前的条形块小于或等于栈顶的条形块,将条形块的索引入栈,即当前的条形块被栈中的前一个条形块界定。
如果发现一个条形块长于栈顶,可以确定栈顶的条形块被当前条形块和栈的前一个条形块界定,因此可以弹出栈顶元素并且累加答案到ans 。
但同时栈内元素的存放和图形的动态变化过程较为抽象,在理解层面需要一定的时间。

posted @ 2020-05-05 00:07  BaiYi#  阅读(299)  评论(0编辑  收藏  举报