二维数组中的递归算法

最新推荐文章于 2022-11-08 14:09:36 发布
最新推荐文章于 2022-11-08 14:09:36 发布
阅读量1.7k 收藏 3
点赞数 2
分类专栏： 算法 文章标签： 面试题 爱奇艺 猿辅导 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L__ear/article/details/98495959
版权

这两道题目分别来自爱奇艺 2017 年内推笔试题和 2019 年猿辅导算法题。

第一题

题目描述

Michael 喜欢滑雪这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael 想知道在一个区域中最长的滑坡。区域由一个二维数组给出，数组的每个数字代表点的高度。下面是一个例子

 1  2  3  4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为 24-17-16-1。当然 25-24-23-…-3-2-1 更长。事实上，这是最长的一条。

输入描述：
输入的第一行表示区域的行数 R 和列数 C（1 <= R,C <= 100）。下面是 R 行，每行有 C 个整数，代表高度 h，0<= h <=10000。

输出描述：
输出最长区域的长度。

示例：

输入：
5 5
1  2  3  4  5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
输出：
25
题目求解

一、递归解法
基于当前点，向四个方向进行递归搜索。假设函数 dfs(i, j) 表示以 (i, j) 为终点的最长滑坡长度。
在不考虑数组越界的情况下，有如下关系：
dfs(i, j) = max{dfs(i-1, j), dfs(i+1, j), dfs(i, j-1), dfs(i, j+1)} + 1。

public class Test {
	private static int dfs(int[][] matrix, int i, int j){
		int up = 0, down = 0, left = 0, right = 0;
		if(i - 1 >= 0 && matrix[i][j] > matrix[i-1][j]) up = dfs(matrix, i-1, j);
		if(i + 1 < matrix.length && matrix[i][j] > matrix[i+1][j]) down = dfs(matrix, i+1, j);
		if(j - 1 >= 0 && matrix[i][j] > matrix[i][j-1]) left = dfs(matrix, i, j-1);
		if(j + 1 < matrix[i].length && matrix[i][j] > matrix[i][j+1]) right = dfs(matrix, i, j+1);
		int x, y;
		return (x = left>right?left:right) > (y = up>down?up:down) ? x+1 : y+1;
	}
	public static void main(String[] args) {
		 int R = 5;
		 int C = 5;
		 int[][] matrix = {
				 {3, 16, 10, 28, 34},
				 {6, 8, 11, 14, 9},
				 {20, 1, 54, 27, 15},
				 {18, 4, 19, 30, 6},
				 {25, 16, 23, 33, 5}};
		 int max = 0;
		 for(int i = 0; i < R; ++i){
			 for(int j = 0; j < C; ++j){
				 int temp = dfs(matrix, i, j);
				 if(temp > max) max = temp;
			 }
		 }
		 System.out.println(max);
	}
}

这个递归算法还是很简洁直观的，形式上也具有一定的对称美。因为二维数组的每个点都有可能是最长滑坡的终点，所以需要对每个点都搜索一遍。可以很容易看到，由于没有保存之前的搜索结果，该算法会有大量重复的搜索，我们可以通过空间换时间的方法降低算法的时间复杂度。

import java.util.Arrays;
public class Test {
	private static int dfs(int[][] cache, int[][] matrix, int i, int j){
		if(cache[i][j] != 0) return cache[i][j];
		int up = 0, down = 0, left = 0, right = 0;
		if(i - 1 >= 0 && matrix[i][j] > matrix[i-1][j]){
			if(cache[i-1][j] == 0){
				up = dfs(cache, matrix, i-1, j);
				cache[i-1][j] = up;
			}else up = cache[i-1][j];
		}
		if(i + 1 < matrix.length && matrix[i][j] > matrix[i+1][j]){
			if(cache[i+1][j] == 0){
				down = dfs(cache, matrix, i+1, j);
				cache[i+1][j] = down;
			}else down = cache[i+1][j];
		}
		if(j - 1 >= 0 && matrix[i][j] > matrix[i][j-1]){
			if(cache[i][j-1] == 0){
				left = dfs(cache, matrix, i, j-1);
				cache[i][j-1] = left;
			}else left = cache[i][j-1];
		}
		if(j + 1 < matrix[i].length && matrix[i][j] > matrix[i][j+1]){
			if(cache[i][j+1] == 0){
				right = dfs(cache, matrix, i, j+1);
				cache[i][j+1] = right;
			}else right = cache[i][j+1];
		}
		int x, y;
		cache[i][j] = (x = left>right ? left : right) > (y = up>down ? up : down) ? x+1 : y+1;
		return cache[i][j];
	}
	public static void main(String[] args) {
		 int R = 5;
		 int C = 5;
		 int[][] matrix = {
				 {3, 16, 10, 28, 34},
				 {6, 8, 11, 14, 9},
				 {20, 1, 54, 27, 15},
				 {18, 4, 19, 30, 6},
				 {25, 16, 23, 33, 5}};
		 int[][] cache = new int[R][C];
		 int max = 0;
		 for(int i = 0; i < R; ++i){
			 for(int j = 0; j < C; ++j){
				 int temp = dfs(cache, matrix, i, j);
				 if(temp > max) max = temp;
			 }
		 }
		 System.out.println(Arrays.deepToString(cache));
		 System.out.println(max);
	}
}

二、非递归解法
非递归解法需要对数组元素排序，所以效率没有改进后的递归算法高。
思路就是，开辟一个辅助数组 cache，cache[i][j] 表示以 (i, j) 为终点的最长滑坡长度，按照原数组中值从小到大的顺序来处理 cache 数组对应位置的值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Index implements Comparable<Index>{ // 定义存放数组值以及对应下标的可比较类
	int i, j, value;
	public Index(int i, int j, int value) {
		this.i = i;
		this.j = j;
		this.value = value;
	}
	@Override
	public int compareTo(Index o) {
		return value-o.value;
	}
}
public class Test {
	// 按照 matrix 数组中值从小到大的顺序，处理 cache 数组
	private static int pathLength(List<Index> indexs, int [][] cache, int r, int c){
		int max = 0;
		for(Index e : indexs){
			int i = e.i, j = e.j;
			int up = 0, down = 0, left = 0, right = 0;
			if(i-1 >= 0) up = cache[i-1][j];
			if(i+1 < r) down = cache[i+1][j];
			if(j-1 >= 0) left = cache[i][j-1];
			if(j+1 < c) right = cache[i][j+1];
			int x, y;
			cache[i][j] = (x = left>right?left:right) > (y = up>down?up:down) ? x+1 : y+1; 
			if(cache[i][j] > max) max = cache[i][j];
		}
		return max;
	}
	public static void main(String[] args) {
		int R = 5;
		 int C = 5;
		 int[][] matrix = {
				 {3, 16, 10, 28, 34},
				 {6, 8, 11, 14, 9},
				 {20, 1, 54, 27, 15},
				 {18, 4, 19, 30, 6},
				 {25, 16, 23, 33, 5}};
		 List<Index> indexs = new ArrayList<>();
		 for(int i = 0; i < R; ++i){
			 for(int j = 0; j < C; ++j){
				 indexs.add(new Index(i, j, matrix[i][j]));
			 }
		 }
		 Collections.sort(indexs);
		 int[][] cache = new int[R][C];
		 System.out.println(pathLength(indexs, cache, R, C));
	}
}

第二题

题目描述

有一个 N*M 的迷宫矩阵，迷宫的每个格子有一个数值（a[i][j] < 10^9）。小猿在迷宫中发现，它只能朝着上下左右四个方向的相邻格子前进，并且只能进入到比当前格子数值更大的格子。但是小猿有一个紧急呼救按钮，他可以通过按下按钮，强行进入到不满足数值大小要求的相邻格子，可惜这个按钮只能按 K 次。请问小猿从这个迷宫任远一个格子出发，在紧急按钮的帮助下，最多能走多少步（开始位置计入步数，即站在起点的步数为 1）。

输入描述：
第一行输入三个数 N，M，K。接下来 N 行，每行 M 个数，表示迷宫每个格子的值。
1 <= N <= 500
1 <= M <= 500
0 <= K <= 10

输出描述：
输出小猿能在迷宫中走的最大步数。

示例：

输入：
3	3	1
1	3	3
2	4	9
8	9	2
输出：
6
题目求解

可以看出，本题是上一题的升级版，使用递归求解如下：

public class Test {
	private static int dfs(int[][] matrix, int k, int i, int j){
		int up = 0, down = 0, left = 0, right = 0;
		if(i-1 >= 0){
			int up0 = 0, up1 = 0;
			if(matrix[i][j] < matrix[i-1][j]){
				up0 = dfs(matrix, k, i-1, j);
			}else if(k > 0){
				up1 = dfs(matrix, k-1, i-1, j);
			}
			up = up0>up1 ? up0 : up1;
		}
		if(i+1 <= matrix.length-1){
			int down0 = 0, down1 = 0;
			if(matrix[i][j] < matrix[i+1][j]){
				down0 = dfs(matrix, k, i+1, j);
			}else if(k > 0){
				down1 = dfs(matrix, k-1, i+1, j);
			}
			down = down0>down1 ? down0 : down1;
		}
		if(j-1 >= 0){
			int left0 = 0, left1 = 0;
			if(matrix[i][j] < matrix[i][j-1]){
				left0 = dfs(matrix, k, i, j-1);
			}else if(k > 0){
				left1 = dfs(matrix, k-1, i, j-1);
			}
			left = left0>left1 ? left0 : left1;
		}
		if(j+1 <= matrix[i].length-1){
			int right0 = 0, right1 = 0;
			if(matrix[i][j] < matrix[i][j+1]){
				right0 = dfs(matrix, k, i, j+1);
			}else if(k > 0){
				right1 = dfs(matrix, k-1, i, j+1);
			}
			right = right0>right1 ? right0 : right1;
		}
		int x, y;
		return (x = right>left?right:left) > (y = up>down?up:down) ? x+1 : y+1;
	}
	public static void main(String[] args) {
		int N = 3;
		int M = 3;
		int K = 1;
		int[][] matrix = {{1,3,3},{2,4,9},{8,9,2}};
		int max = 0;
		for(int i = 0; i < N; ++i){
			for(int j = 0; j < M; ++j){
				int temp = dfs(matrix, K, i, j);
				if(temp > max) max = temp;
			}
		}
		System.out.println(max);
	}
}

同理，空间换时间。

import java.util.Arrays;
public class Test {
	private static int dfs(int[][][] cache, int[][] matrix, int k, int i, int j){
		if(cache[k][i][j] != 0) return cache[k][i][j];
		int up = 0, down = 0, left = 0, right = 0;
		if(i-1 >= 0){
			int up0 = 0, up1 = 0;
			if(matrix[i][j] < matrix[i-1][j]){
				if(cache[k][i-1][j] == 0){
					up0 = dfs(cache, matrix, k, i-1, j);
					cache[k][i-1][j] = up0;					
				}else up0 = cache[k][i-1][j];
			}else if(k > 0){
				if(cache[k-1][i-1][j] == 0){
					up1 = dfs(cache, matrix, k-1, i-1, j);
					cache[k-1][i-1][j] = up1;
				}else up1 = cache[k-1][i-1][j];
			}
			up = up0>up1 ? up0 : up1;
		}
		if(i+1 <= matrix.length-1){
			int down0 = 0, down1 = 0;
			if(matrix[i][j] < matrix[i+1][j]){
				if(cache[k][i+1][j] == 0){
					down0 = dfs(cache, matrix, k, i+1, j);
					cache[k][i+1][j] = down0;
				}else down0 = cache[k][i+1][j];
			}else if(k > 0){
				if(cache[k-1][i+1][j] == 0){					
					down1 = dfs(cache, matrix, k-1, i+1, j);
					cache[k-1][i+1][j] = down1;
				}else down1 = cache[k-1][i+1][j];
			}
			down = down0>down1 ? down0 : down1;
		}
		if(j-1 >= 0){
			int left0 = 0, left1 = 0;
			if(matrix[i][j] < matrix[i][j-1]){
				if(cache[k][i][j-1] == 0){					
					left0 = dfs(cache, matrix, k, i, j-1);
					cache[k][i][j-1] = left0;
				}else left0 = cache[k][i][j-1];
			}else if(k > 0){
				if(cache[k-1][i][j-1] == 0){					
					left1 = dfs(cache, matrix, k-1, i, j-1);
					cache[k-1][i][j-1] = left1;
				}else left1 = cache[k-1][i][j-1];
			}
			left = left0>left1 ? left0 : left1;
		}
		if(j+1 <= matrix[i].length-1){
			int right0 = 0, right1 = 0;
			if(matrix[i][j] < matrix[i][j+1]){
				if(cache[k][i][j+1] == 0){
					right0 = dfs(cache, matrix, k, i, j+1);
					cache[k][i][j+1] = right0;
				}else right0 = cache[k][i][j+1];
			}else if(k > 0){
				if(cache[k-1][i][j+1] == 0){
					right1 = dfs(cache, matrix, k-1, i, j+1);
					cache[k-1][i][j+1] = right1;
				}else right1 = cache[k-1][i][j+1];
			}
			right = right0>right1 ? right0 : right1;
		}
		int x, y;
		cache[k][i][j] = (x = right>left ? right : left) > (y = up>down ? up : down) ? x+1 : y+1;
		return cache[k][i][j];
	}
	public static void main(String[] args) {
		int N = 3;
		int M = 3;
		int K = 1;
		int[][] matrix = {{1,3,3},{2,4,9},{8,9,2}};
		int[][][] cache = new int[k+1][N][M];
		int max = 0;
		for(int i = 0; i < N; ++i){
			for(int j = 0; j < M; ++j){
				int temp = dfs(cache, matrix, K, i, j);
				if(temp > max) max = temp;
			}
		}
		System.out.println(Arrays.deepToString(cache));
		System.out.println(max);
	}
}

总结

公司的算法题都比较冗长，题目里往往包含多余的人物和故事，不像 leetcode 那样简单直接。我猜测可能是考虑到在线笔试时，如果题目出的太直接，会比较容易搜到答案或思路。做这些题目时一般都有比较紧张的时间限制，容不得太发散的思考，像这种题目，首先考虑递归（因为递归相对简洁直观），靠谱就写，不能太花时间琢磨非递归的算法，而且就算琢磨出来了，效率也不一定有递归算法高。

L__ear
关注
专栏目录
回溯法与递归 C++中动态的二维数组
Better Explained
12-22 1349
leetcode的题目，求出数独游戏的一个解。 之前记得求解 全排列和八皇后问题也是用的回溯法。 分治法可以用递归是很显然的，它们俩是天生一对；回溯法也可以。因为 试探求解 子问题。 下面代码是递归回溯求解数独的一个解，6个测试用例，184ms，在C++分布段上处在中间，还行吧，以后有时间再研究。   关键是学到了一种方便地表示动态二维数组的新方法。一维的动态数组 就用new[]、vec
java二维数组合并_二维数组交叉组合算法
weixin_39981041的博客
02-16 735
一、名词解释1、多维：描述一个实体的不同属性，如：颜色、尺寸、价格2、散列：每个属性有多个属性值，且数量不一4、分组：对属性值进行组合，不可出现完全相同组合，且每组数量必须等于属性个数，用来表明一个唯一实体3、交叉组合：每个属性中分别取值进行组合，顺序不受限制，必须保证每种可能性都有出现4、原子：每个属性中具体值二、变量定义说明1、原子的出现次数 = $times2、属性值个数 = $valCou...
二维数组与递归
xuefeiyuan1995的博客
04-12 567
一、二维数组 1.1、二维数组概述 其实二维数组其实就是每一个元素为一维数组的数组。 1.2、二维数组定义格式及内存图解 二维数组格式1 数据类型[ ] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可选 举例: int [][] arr=new int [3][2]; 定义了一个二维数组arr,这个二维数组有3个一维...
二维数组+递归
Pig-pig-pig的博客
04-10 1723
一.二维数组 1.定义 二维数组其实就是每一个元素为一维数组的数组。 2.定义格式: 数据类型[][] 数组名=new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可写可不写,写与不写有区别 例如: int[][] arr=new int[3][2]; 1.数组名为arr 2.数组长度为3,即存放的一维数组的个数为3, 3.每个一...
二维数组递归算法c语言,JavaScript 递归法排列组合二维数组
weixin_39801075的博客
05-19 327
二维数组排列组合var arrays = [['1-1-雨尘', '1-2-芸芸', '1-3-简一', '1-4-乐乐'], ['2-5-小明', '2-6-花花', '2-7-数数'], ['3-8-静静', '3-9-点点', '3-10-hapday', '3-11-欢欢', '3-12-yuchen']];//debugger;/*** 递归法排列组合二维数组*/function doE...
递归及二维数组
09-29 1614
方法的递归调用： 示例： sum(n) 代表等差数列的前n项的和 sum(n) = n + sum(n-1) and n>=1; 1 2 3 4 5 static int sum(int n){ if(n==1) return n; return n + sum
php 二维数组快速排序算法的实现代码
10-19
总结来说，这个PHP实现的快速排序算法是通过递归的方式，基于二维数组中'score'属性的比较，对数组进行排序。尽管代码简洁，但有效地实现了快速排序算法在二维数组场景下的应用。这种算法的效率较高，平均时间复杂度...
JS实现二维数组元素的排列组合运算简单示例
10-17
在JavaScript中实现二维数组元素的排列组合，有助于理解和掌握数组操作、递归、回溯等编程技巧。 在具体实现上，需要了解如何通过JavaScript代码遍历二维数组中的所有元素，并对这些元素进行排列组合运算。通常，这...
用递归查找有序二维数组的方法详解
09-05
在本文中，我们将深入探讨如何使用递归方法在一个有序的二维数组中查找特定的整数。有序二维数组是指每行从左到右递增，每列从上到下递增的数组。这样的结构使得我们可以采用一种高效的方式来搜索目标值，而无需遍历...
C++函数模板递归一二维数组动态分配存储空间实例1
hsg77的专栏
07-05 1294
C++函数模板递归一二维数组动态分配存储空间实例1
C++二维矩阵 排序 递归
04-09
资源包括了二维矩阵相关操作的练习源代码，和排序的容器实现，以及递归的练习源代码。
递归实现二维数组输出
无
11-25 829
非递归实现: private static void findWords(int[][]board ,int index){//index可以不需要了 for (int i = 0; i &lt;board.length ; i++) { for (int j = 0; j &lt;board[0].length ; j+...
Java中的二维数组和递归
weixin_45082647的博客
12-10 503
1、二维数组 前面已经学习过数组了，知道数组就是一种数据结构，用来存储同一类型值的集合，通过一个下标可以访问数组中的每个值。 一维数组用来表示一列数，二维数组可以表示一张表（比如一个班级里面有若干学生，学校里面有很多班级，这时候数据也需要用数组表示）。由此可见，二维数组其实就是每一个元素为一维数组的数组。 二维数组定义格式1： 数据类型[ ][ ] arr = new 数据类型[m[n]; m表...
二维数组排序[递归、回溯]
fantastic的博客
08-26 195
给定条件排序，存在优化空间，使用递归方式，仅仅作为思路 var list = [{ age: 3, height: 1, weight: 2, }, { age: 1, height: 2, weight: 3, }, { age: 1, height: 1, weight: 3, }, { age: 1, height: 1, weight: 1, }, { age: 6, height: 0, weight: 1, }, { age: 6,
二维数组和递归
weixin_44821160的博客
04-09 518
二维数组和递归 二维数组 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。二维数组其实就是每一个元素为一维数组的数组。 二维数组格式： 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可选 或 二维数组格式2 数据类型[][] 变量名...
c语言 扫雷游戏（二维数组的灵活运用）递归运用
qq_51004011的博客
02-05 2654
主函数的实现 void menu() { printf("****************************\n"); printf("****** 1:play *******\n"); printf("****** 0:exit *******\n"); printf("****************************\n"); } void game() { //创建两数组，一个用来埋雷，一个展示。 char mein[ROWS][COLS]
java中用递归遍历二维数组
xunrenbuyu的博客
07-20 2175
    在java中二维数组用到的比较少，对于二维数组的遍历并不难，通过for循环，增强for很简单就可以实现，不过我们知道对于递归可以简单理解为循环，那么有没有想过用递归进行遍历二维数组呢？ 对于递归，个人理解为，自己调用自己的方法，从而实现循环功能，最重要的两点：1 要有出口，避免陷入死循环，2 要注意不要调用的次数过多，防止内存报错； 下面就简单尝试了一下用递归解决二维数组遍历问题，对...
[Java语言基础]一维数组、二维数组、递归
Hi~ 土拨鼠
10-06 238
老正又来啦~ 数组 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。 数组既可以存储基本数据类型，也可以存储引用数据类型。 学习数组之前，我们首先得了解一下内存的分配: 栈: 存放的是局部变量 局部变量：在方法定义中或者方法声明上的变量都是局部变量。 堆: 存放的是所有new出来的东西 特点： a: 每一个new出来的东西都会为其分配一个地制值。 b: 每一个变量都有一个默...
函数递归与一维、二维数组
最新发布
Elon_520的博客
11-08 299
学习小结
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值