矩阵中最长的递增路径(深度优先)

题目描述

给定一个整数矩阵,找出最长递增路径的长度。

对于每个单元格,你可以往上,下,左,右四个方向移动。 你不能在对角线方向上移动或移动到边界外(即不允许环绕)。

示例 1:

输入: nums = 
[
  [9,9,4],
  [6,6,8],
  [2,1,1]

输出: 4 
解释: 最长递增路径为 [1, 2, 6, 9]。
示例 2:

输入: nums = 
[
  [3,4,5],
  [3,2,6],
  [2,2,1]

输出: 4 
解释: 最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

题目思路:

求矩阵中的最长的递增路径,可以以每个单元格为起始点,分别求出路径,比较最长的即可。因为每个单元格的最长路径是不变的,为了减少不必要的重复计算我们可以用一个新的二维数组来记录每个单元格的路径长度。先初始化为0,访问时如果值为0说明没有访问过,不为0说明以前访问过,那么直接用改单元格的路径长度即可。

具体代码实现:

#include<iostream>
#include<vector>
using namespace std;

int mov[4][2]={{-1,0},{1,0},{0,-1},{0,1}};

class Solution {
public:
   //代表上下左右的操作:以{-1,0}为例,行-1,列不变那就说明是向上移动了
  
	int longestIncreasingPath(vector<vector<int>>& matrix) 
	{
		int rows=matrix.size();//行,;
		int cols=matrix[0].size();//列;
		if(rows==0 || cols==0)//判断形参的合法性
		{
			return 0;
		}
		vector<vector<int>> help(rows,vector<int> (cols));//与矩阵同样结构的数组
		int maxload=0;//最长递增序列的值
		for(int i=0;i<rows;i++)
		{
			for(int j=0;j<cols;j++)
			{
				maxload=max(maxload,dfs(matrix,help,i,j));//把矩阵中的每一个单元格进行深度遍历计算出路径,同时更新maxload的值
			}
		}
		return maxload;
	}
	int dfs(vector<vector<int>>& matrix,vector<vector<int>> &help,int row,int col)//深度遍历单元格
	{
		//深度遍历就是递归的一个过程
		int rows=matrix.size();//行,;
		int cols=matrix[0].size();//列;
		if(help[row][col]!=0)//说明以前计算过
		{
			return help[row][col];//返回以前计算出的值
		}
		++help[row][col];//单元格自己本身就算一条路径
		for(int i=0;i<4;i++)
		{
			int newrow=row+mov[i][0];//行数只看二维数组第一列
			int newcol=col+mov[i][1];//列数i只看二维数组第二列
			if(rows>newrow && newrow>=0 && newcol>=0 && cols>newcol && matrix[row][col]<matrix[newrow][newcol])//判断越界,判断移动后的值是否大于原来的值
			{
				help[row][col]=max(help[row][col],dfs(matrix,help,newrow,newcol)+1);//和以前移动的数值进行比较,取大值。注意要+1因为要加上现在这个单元格:比如以前的路径是2,3,4。最长序列就是3,现在搜索1时候到了2,所以新序列要加上1.
			}
		}
		return help[row][col];
	}
};
int main()
{
	int arr[3][3]={3,4,5,3,2,6,2,2,1};
	vector<vector<int>> brr(3,vector<int>(3));
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
		{
			brr[i][j]=arr[i][j];
		}
	}
	Solution a;
	int c=a.longestIncreasingPath(brr);
	printf("%d",c);
	return 0;
}



 

  • 0
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
邻接矩阵是一种图的存储结构,它可以用来表示有限个顶点之间的关系。邻接矩阵深度优先遍历和广度优先遍历是图的两种基本遍历方式。 邻接矩阵深度优先遍历(Depth First Search,DFS): 深度优先遍历是一种用于遍历或搜索树或图的算法。在这个算法,首先访问根节点,然后递归地访问每个子节点。当访问一个节点时,将其标记为已访问,以避免重复访问。深度优先遍历使用栈来实现,因此它是一种先进后出(Last In First Out,LIFO)的算法。 下面是邻接矩阵深度优先遍历的Python代码示例: ```python def DFS(graph, start): visited = set() # 用集合来存储已经访问过的节点 stack = [start] # 用列表来模拟栈 while stack: vertex = stack.pop() # 取出栈顶元素 if vertex not in visited: visited.add(vertex) # 标记为已访问 print(vertex, end=' ') # 将未访问的邻居节点入栈 stack.extend([i for i in range(len(graph[vertex])) if graph[vertex][i] and i not in visited]) # 示例 graph = [[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]] DFS(graph, 0) # 输出:0 1 3 2 ``` 邻接矩阵的广度优先遍历(Breadth First Search,BFS): 广度优先遍历是一种用于遍历或搜索树或图的算法。在这个算法,首先访问根节点,然后逐层访问每个子节点。当访问一个节点时,将其标记为已访问,以避免重复访问。广度优先遍历使用队列来实现,因此它是一种先进先出(First In First Out,FIFO)的算法。 下面是邻接矩阵的广度优先遍历的Python代码示例: ```python from collections import deque def BFS(graph, start): visited = set() # 用集合来存储已经访问过的节点 queue = deque([start]) # 用双端队列来模拟队列 while queue: vertex = queue.popleft() # 取出队首元素 if vertex not in visited: visited.add(vertex) # 标记为已访问 print(vertex, end=' ') # 将未访问的邻居节点入队 queue.extend([i for i in range(len(graph[vertex])) if graph[vertex][i] and i not in visited]) # 示例 graph = [[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]] BFS(graph, 0) # 输出:0 1 2 3 ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值