题目描述：

小明有一个大小为N×M的矩阵，可以理解为一个N行M列的二维数组。 我们定义一个矩阵m 的稳定度f(m)
为f(m)=max(m)-min(m)。 其中max(m)表示矩阵m中的最大值，min(m) 表示矩阵m 中的最小值。
现在小明想要从这个矩阵中找到一个稳定度不大于limit 的子矩阵； 同时他还希望这个子矩阵的面积越大越好（面积可以理解为矩阵中元素个数）。

子矩阵定义如下：

从原矩阵中选择一组连续的行和一组连续的列，这些行列交点上的元素组成的矩阵即为一个子矩阵。

输入格式：

第一行输入两个整数N，M，表示矩阵的大小。 接下来N 行，每行输入M 个整数，表示这个矩阵。 最后一行输入一个整数limit，表示限制。

对于所有评测用例，0≤矩阵元素值, limit≤10^5。

输出格式：

输出一个整数，分别表示小明选择的子矩阵的最大面积。

输入样例：

3 4
2 0 7 9
0 6 9 7
8 4 6 4
8

输出样例：

6

数据范围与提示

满足稳定度不大于8 的且面积最大的子矩阵总共有三个，他们的面积都是6（粗体表示子矩阵元素）：

2 0 7 9
0 6 9 7
8 4 6 4

2 0 7 9
0 6 9 7
8 4 6 4

2 0 7 9
0 6 9 7
8 4 6 4

解题思路：

本题采用dfs + 回溯的思想来解决，也就是朴素的暴搜。

若要利用好深搜索得先搞清以下问题：

1.应先明确遍历的起点：
数组中每个元素都可以是起点，这样能无死角地找到所有符合条件的子矩阵。 所以我们要对数组内每个点都进行遍历，不断更新面积最大值。

2.如何知道我们遍历过的符合条件的区域是一个矩阵？（这是我们更新子矩阵面积所必需要知道的。）

“对号”部分是是我们遍历过的区域。

很明显这不是一个矩阵，但是若我们知道遍历过的点的横坐标范围，和纵坐标的范围，问题就解决了。

知道范围后，在这个范围内（即蓝色区域内）遍历一下看看是不是所有点都被遍历过，是则满足子矩阵，否则不满足，这需要单独构建一个布尔数组，和一个判断是否为矩阵的函数。

3.遍历规则：
我们知道 深度优先遍历是一个路径，而我们想要的是子矩阵。
即如果我么们给的限制条件只是在数组区间内遍历，那么它就会在这个区间乱窜。所以我么们需要施加新条件来限制它的遍历轨迹，确保以遍历子矩阵为优先。
即，如果当前遍历路径不是子矩阵的话，我们就将当前所在矩阵区域遍历满。如果当前遍历区域是一个子矩阵的话，我们就扩大边界，试着去得到面积更大的符合条件的子矩阵。

4.遍历过程的模拟：

理清思路后我们可以模拟一下遍历过程，以确保万无一失。想学好 dfs 会模拟自己写的程序是必不可少的。

以题目中例1的遍历为例以下是我的模拟过程，可以助于理解：

理论成立代码如下：

import java.util.Scanner;

public class Main {
    public static int n = 0;
    public static int m = 0;
	public static void main(String[] args){
       Scanner sc = new Scanner(System.in);
       n = sc.nextInt();
       m = sc.nextInt();
       int a[][] = new int[n + 10][m + 10];//储存数组
       visit = new boolean[n][m];
       for(int i = 0; i < n; i ++)
    	   for(int j = 0; j < m; j ++) a[i][j] = sc.nextInt();
       
       f = sc.nextInt();
       
       for(int i = 0; i < n; i ++)
    	   for(int j = 0; j < m; j ++) {
    		   mini = i;
    		   minj = j;
    		   maxi = i;
    		   maxj = j; 
    		   sunmatrix = 1;
    		   minvalue = a[i][j];
    		   maxvalue = a[i][j];	   // 初始化
    		   
    		   visit[i][j] = true;//标记
    		   dfs(a, i, j);
    		   visit[i][j] = false;//回溯
    		   
    		   maxsmatrix = Math.max(sunmatrix, maxsmatrix);//更新
    		   
    	   }
       
       System.out.print(maxsmatrix);//最终结果
       
}
   public static boolean visit[][];//储存路径
   public static int mini = 0;
   public static int maxi = 0;
   public static int minj = 0;
   public static int maxj = 0;//储存矩阵范围
   
   public static int f = 0;//储存题目要求稳定度
  
   public static int minvalue = 0;
   public static int maxvalue = 0;//储存遍历过的路径最大值与最小值
   
   public static int sunmatrix = 0;//储存每次遍历最大面积
   public static int maxsmatrix = 0; // 储存最终答案
   
   public static void updatemx(int i, int j) {//更新遍历的矩阵范围
	   mini = Math.min(mini, i);
	   minj = Math.min(minj, j);
	   maxi = Math.max(maxi, i);
	   maxj = Math.max(maxj, j);
   }
   
   public static int F(int value) {//判断矩阵稳定度
	   minvalue = Math.min(minvalue, value);
	   maxvalue = Math.max(maxvalue, value);//更新
	   
	   return maxvalue - minvalue;
   }
   
   public static void dfs(int a[][], int i, int j) {
 
	   if(ifmatrix() && F(a[i][j]) <= f)//最重要的事情最先做，如果路径满足矩阵且新点符合条件，更新子矩阵面积
		   sunmatrix = Math.max(sunmatrix, (maxi - mini + 1) * (maxj - minj + 1));//新子矩阵面积计算过程
	   
	   
	   int fxx = 0, fyy = 0;
	   int fx[] = {-1, 1, 0, 0};
	   int fy[] = {0, 0, -1, 1};//上下左右
	   
	   for(int k = 0; k < 4; k ++) {
		   fxx = i + fx[k];
		   fyy = j + fy[k];
		   
		   int bfmini = mini;
		   int bfmaxi = maxi;
		   int bfminj = minj;
		   int bfmaxj = maxj; 
		   int bfminvalue = minvalue;
		   int bfmaxvalue = maxvalue;//存着用于回溯
		   
		   if(ifmatrix()) {//是矩阵，扩张
			   if(fxx >= 0 && fxx < n && fyy >= 0 && fyy < m && visit[fxx][fyy] != true && F(a[fxx][fyy]) <= f) {
				   visit[fxx][fyy] = true;//标记来过
				   updatemx(fxx, fyy);//更新边界
				   dfs(a, fxx, fyy);
				   visit[fxx][fyy] = false;
			   }
		   }
		   else {//否者把目前范围矩阵遍历完
			   if(fxx >= mini && fxx <= maxi && fyy >= minj && fyy <= maxj && visit[fxx][fyy] != true && F(a[fxx][fyy]) <= f) {
				   visit[fxx][fyy] = true;
				   updatemx(fxx, fyy);
				   dfs(a, fxx, fyy);
				   visit[fxx][fyy] = false;
			   }
		   }
		   minvalue = bfminvalue;
		   maxvalue = bfmaxvalue;//回溯
		   mini = bfmini;
		   minj = bfminj;
		   maxi = bfmaxi;
		   maxj = bfmaxj;
	   }
	   
   }
   
   public static boolean ifmatrix() {//判断此路径是否是矩阵
	   for(int i = mini; i <= maxi; i ++)
		   for(int j = minj; j <= maxj; j ++)
			   if(visit[i][j] != true)  return false;
	   return true;
   }  
}

此代码虽然长，但只要弄懂上述问题，逐一解决，条理还是很清晰的，本代码在官方平台上测试能搞到九成分数，剩下的两个测试点是超时了。能对的都对了。想拿满分的话可以看看别的大佬写的别的方法，对于我来说如果真让我在赛场上遇到这道题的话，我能用这个朴素爆搜混点分就很满足的，打死也想不出其他方法了。

此代码能优化的我也优化了，如果有些地方还可以优化的话，欢迎各大佬指点。