华为OD 最小矩阵宽度（java）

题目描述：

给定一个矩阵，包含N*M个整数，和一个包含K个整数的数组。

现在要求在这个矩阵中找一个宽度最小的子矩阵，要求子矩阵包含数组中所有的整数。

输入描述：

第一行输入两个正整数N，M，表示矩阵大小。
接下来N行M列表示矩阵内容。
下一行包含一个正整数K。
下一行包含K个整数，表示所需包含的数组，K个整数可能存在重复数字
所有输入数据小于1000。

输出描述：

输出包含一个整数，表示满足要求子矩阵的最小宽度，若找不到，输出-1.

示例1

输入：

2 5
1 2 2 3 1
2 3 2 3 2
3
1 2 3

输出：

2

说明：

矩阵第0、3列包含了1、2、3，矩阵第3、4列包含了1、2、3

示例2

输入：

2 5
1 2 2 3 1
1 3 2 3 4
3
1 1 4

输出：

5

说明：

矩阵第1、2、3、4、5列包含了1、1、4

代码

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] arr = new int[n][m];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                arr[i][j] = in.nextInt();
            }
        }
        int k = in.nextInt();
        List<Integer> dp = new ArrayList<>();
        for(int i=0;i<k;i++){
            dp.add(in.nextInt());
        }

        int sum = m;
        int temp = 0;
        int count = 0;
        for(int i=0;i<m;i++){
            temp=f(arr,dp,0);
            if(temp!=-1){
                count++;
                sum=Math.min(sum,temp);
            }

        }
        if(count==0){
            System.out.println(-1);
        }else {
            System.out.println(sum);
        }

    }

    private static int f(int[][] arr, List<Integer> dp, int n) {
        List<Integer> list = new ArrayList<>(dp);
        int temp = 0;
        for(int i=n;i<arr[0].length;i++){
            for(int j=0;j<arr.length;j++){
                if(list.contains(arr[j][i])){
                    dp.remove(Integer.valueOf(arr[j][i]));
                    if(dp.isEmpty()){
                        temp=i+1;
                        return temp-n;
                    }
                }
            }
        }
        return -1;
    }


}