题目 2675:蓝桥杯2022年第十三届省赛真题-最大子矩阵

题意：对于一个N*M大小的矩阵，在其中寻找一个子矩阵，该子矩阵在符合limit限制的前提下面积要尽量的大

我首先想到的是暴力枚举：

枚举出所有的子矩阵，对于符合limit限制的子矩阵，记录其面积，最后输出最大面积

如何得到子矩阵呢：

外层两个for循环，枚举子矩阵所有的形状

对每个形状，将其左上角放在原矩阵的每一个点位上，对于能放得下的子矩阵，为其赋值，判断limit限制，记录面积。（这里为子矩阵的左上角在原矩阵中寻找位点又需要两层for循环，超时肯定不可避免了，先不管，做出来再说）

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt() , m = sc.nextInt();
        int[][] arr = new int[n][m];
        for(int i=0 ; i<n ; i++) {
            for(int j=0 ; j<m ; j++) {
                arr[i][j]=sc.nextInt();
            }
        }
        int limit = sc.nextInt();
        sc.close();
        int max=-1;    //记录最大面积
        
//        System.out.println("limit:"+limit);
//        System.out.println("稳定度:"+f(arr));
//        System.out.println("面积:"+area(arr));
        
        for(int i=1 ; i<=n ; i++) {
            for(int j=1 ; j<=m ; j++) {
                //此处 i*j 是所有子矩阵的形状
//                System.out.println(">子矩阵形状："+i+"*"+j+"-------");
                //遍历原矩阵的每一个位点，看当前子矩阵的形状是否可以放得进原矩阵
                for(int x=1 ; x<=n ; x++) {
                    for(int y=1 ; y<=m ; y++) {
//                        System.out.println(">>目标位点：("+x+","+y+")");
                        boolean pd = putdown(arr,x,y,i,j);
//                        if(pd) System.out.println(">>>可以放下√√√");
//                        else System.out.println(">>>不能放下xxx");
                        
                        //此时有大小为i*j的子矩阵，左上角与原矩阵的第x行、第y列对应
                        if(pd) {
                            int[][] subArr = new int[i][j];
                            arrcopy(arr,subArr,x-1,y-1);
//                            readArr(subArr);
                            if(f(subArr)<limit) {    //符合limit限制，记录面积
                                max=Math.max(max, area(subArr));
                            }
                        }
                    }
                }
            }
        }
        System.out.println(max);
    }
    
    /**
     * 
     * @param arr 原矩阵
     * @param subarr 子矩阵
     * @param x 目标行
     * @param y 目标列
     */
    static void arrcopy(int[][] arr, int[][] subarr, int x, int y) {    //为子矩阵赋值
        for(int i=0 ; i<subarr.length ; i++) {
            for(int j=0 ; j<subarr[0].length ; j++) {
                subarr[i][j] = arr[x+i][y+j];
            }
        }
    }
    
    static int f(int[][] arr) {        //稳定度
        int max=Integer.MIN_VALUE , min=Integer.MAX_VALUE;
        
        for(int i=0 ; i<arr.length ; i++) {
            for(int j=0 ; j<arr[0].length ; j++) {
                max=Math.max(max, arr[i][j]);
                min=Math.min(min, arr[i][j]);
            }
        }
        return max-min;
    }
    
    static int area(int[][] arr) {    //面积
        return arr.length * arr[0].length;
    }
    
    /**
     * @param arr 原矩阵
     * @param n    目标行
     * @param m 目标列
     * @param i 子矩阵行数
     * @param j 子矩阵列数
     * @return 子矩阵在目标行列位置放得下则返回true，否则返回false
     */
    static boolean putdown(int[][] arr, int n, int m, int i, int j) {
        int N = arr.length , M = arr[0].length;
        if(n+i-1<=N && m+j-1<=M) {
            return true;
        }else {
            return false;
        }        
    }
  
    static void readArr(int[][] arr) {    //遍历矩阵
        for(int i=0 ; i<arr.length ; i++) {
            for(int j=0 ; j<arr[0].length ; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.print("\n");
        }
    }
}

测试几个简单的用例都能得到结果，提交到在线评测，果不其然超时一大堆

接下来思考如何优化

上述方法中生成了很多无效的子矩阵

1. 尺寸放不进原矩阵的子矩阵

2. 面积小于已知max的子矩阵

优化办法

a. 转换内外循环位置，根据原矩阵中的位点来生成子矩阵

b. 尺寸小于已知max的子矩阵不再继续生成与判断

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt() , m = sc.nextInt();
        int[][] arr = new int[n][m];
        for(int i=0 ; i<n ; i++) {
            for(int j=0 ; j<m ; j++) {
                arr[i][j]=sc.nextInt();
            }
        }
        int limit = sc.nextInt();
        sc.close();
        int max=Integer.MIN_VALUE;    //记录最大面积
        
        for(int x=1 ; x<=n ; x++) {
            for(int y=1 ; y<=m ; y++) {
                //此处(x,y)是从原数组中选取一个点作为子矩阵的左上角，根据这个点来探索子矩阵的所有大小
                if( (n-x+1)*(m-y+1) < max )
                    continue;    //若该位点可生成的最大子矩阵都小于max了，则跳过该位点
                
                for(int i=x ; i<=n ; i++) {
                    for(int j=y ; j<=m ; j++) {
                        //子矩阵尺寸：(i-x+1)*(j-y+1)
                        if((i-x+1)*(j-y+1)<max)
                            continue;    //优化点：对于面积小于max的子矩阵，不再继续判断
                        
                        int[][] subArr = new int[i-x+1][j-y+1];
                        arrcopy(arr,subArr,x-1,y-1);
                        
                        if(f(subArr)<limit) {
                            max=Math.max(max, area(subArr));
                        }
                    }
                }
            }
        }
        System.out.println(max);
    }
    
    /**
     * 
     * @param arr 原矩阵
     * @param subarr 子矩阵
     * @param x 目标行
     * @param y 目标列
     */
    static void arrcopy(int[][] arr, int[][] subarr, int x, int y) {    //为子矩阵赋值
        for(int i=0 ; i<subarr.length ; i++) {
            for(int j=0 ; j<subarr[0].length ; j++) {
                subarr[i][j] = arr[x+i][y+j];
            }
        }
    }
    
    static int f(int[][] arr) {        //稳定度
        int max=Integer.MIN_VALUE , min=Integer.MAX_VALUE;
        
        for(int i=0 ; i<arr.length ; i++) {
            for(int j=0 ; j<arr[0].length ; j++) {
                max=Math.max(max, arr[i][j]);
                min=Math.min(min, arr[i][j]);
            }
        }
        return max-min;
    }
    
    static int area(int[][] arr) {    //面积
        return arr.length * arr[0].length;
    }
    
    static void readArr(int[][] arr) {    //遍历矩阵
        for(int i=0 ; i<arr.length ; i++) {
            for(int j=0 ; j<arr[0].length ; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.print("\n");
        }
    }

}

结果...有优化，但不多，哈哈哈。。。

没办法，哪怕我是菜鸟，我也知道四层for循环太多了

初次接触算法竞赛，算法储备太少，暂时想不到优化方案了，等想到了再来更新~