【华为秋招机考三道编程题之一】华为校招留学生软件开发工程师-真题机考笔试/题目1最小矩阵宽度（Java & JS & Python & C）20240712

最新推荐文章于 2024-07-15 16:23:33 发布

职豚求职小程序

最新推荐文章于 2024-07-15 16:23:33 发布

阅读量1.2k

点赞数 41

文章标签：华为矩阵 java

本文链接：https://blog.csdn.net/Dgntsj/article/details/140398096

版权

【华为秋招机考三道编程题之一】华为校招留学生软件开发工程师-真题机考笔试/题目1最小矩阵宽度（Java & JS & Python & C）20240712

题目描述

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

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

输入描述

第一行输入两个正整数 N，M，表示矩阵大小。

接下来 N 行 M 列表示矩阵内容。

下一行包含一个正整数 K。

下一行包含 K 个整数，表示所需包含的数组，K 个整数可能存在重复数字。

所有输入数据小于1000。

输出描述

输出包含一个整数，表示满足要求子矩阵的最小宽度，若找不到，输出-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 5 1 2 2 3 1 1 3 2 3 4 3 1 1 4
输出	5
说明	矩阵第1、2、3、4、5列包含了1、1、4

题目解析

华为在线题库_职豚www.zhitunjiaoyu.com/qbank/qbank?id=135&title=%E5%8D%8E%E4%B8%BA%E8%BD%AF%E4%BB%B6%E6%9C%BA%E8%80%83&type=qbank

1.首先，我们需要将给定的矩阵转换为一个二维数组，以便后续操作。

2.然后，我们需要找到包含所需整数的子矩阵。为了实现这一点，我们可以使用滑动窗口的方法。我们从矩阵的第一列开始，逐步向右移动窗口，直到找到一个包含所有所需整数的子矩阵。在每次移动窗口时，我们需要检查当前窗口是否包含所有所需整数。如果包含，则更新最小宽度；如果不包含，则继续向右移动窗口。

3.最后，输出满足要求的子矩阵的最小宽度。如果没有找到满足要求的子矩阵，则输出-1。

JS算法源码

 const rl = require("readline").createInterface({ input: process.stdin });
const iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

(async function () {
  const [n, m] = (await readline()).split(" ").map(Number);
  const matrix = [];
  for (let i = 0; i < n; i++) {
    matrix.push((await readline()).split(" ").map(Number));
  }
  const k = parseInt(await readline());
  const nums = (await readline()).split(" ").map(Number);
  const cnts = new Array(1000).fill(0);
  for (let num of nums) {
    cnts[num]++;
  }

  function getResult() {
    let total = k;
    let minLen = Infinity;
    let l = 0;
    let r = 0;

    while (r < m) {
      for (let i = 0; i < n; i++) {
        const num = matrix[i][r];
        if (cnts[num]-- > 0) {
          total--;
        }
      }

      while (total == 0) {
        minLen = Math.min(minLen, r - l + 1);
        for (let i = 0; i < n; i++) {
          const num = matrix[i][l];
          if (cnts[num]++ >= 0) {
            total++;
          }
        }
        l++;
      }
      r++;
    }

    return minLen === Infinity ? -1 : minLen;
  }

  console.log(getResult());
})();

Java算法源码

import java.util.Scanner;

public class Main {
  static int n;  
  static int m;  
  static int[][] matrix;  

  static int k;  
  static int[] cnts;  

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    n = sc.nextInt();
    m = sc.nextInt();

    matrix = new int[n][m];

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        matrix[i][j] = sc.nextInt();
      }
    }

    k = sc.nextInt();

    cnts = new int[1000];
    for (int i = 0; i < k; i++) {
      int num = sc.nextInt();
      cnts[num]++;
    }

    System.out.println(getResult());
  }

  public static int getResult() {
      int total = k;

     int minLen = Integer.MAX_VALUE;

     int l = 0;
     int r = 0;

      while (r < m) {

        for (int i = 0; i < n; i++) {
         int num = matrix[i][r];
           if (cnts[num]-- > 0) {
          total--;
        }
      }

        while (total == 0) {
          minLen = Math.min(minLen, r - l + 1);

          for (int i = 0; i < n; i++) {
          
          int num = matrix[i][l];

            if (cnts[num]++ >= 0) {
            total++;
          }
        }

         l++;
      }
 
      r++;
    }

    if (minLen == Integer.MAX_VALUE) {
      return -1;
    } else {
      return minLen;
    }
  }
}

Python算法源码

import sys
from collections import Counter

def count_numbers(nums):
    return Counter(nums)

def get_result(matrix, k, nums):
    total = k
    min_len = sys.maxsize
    left = 0
    right = 0

    while right < len(matrix[0]):
        for row in matrix:
            num_right = row[right]
            if nums[num_right] > 0:
                total -= 1
                nums[num_right] -= 1

        while total == 0:
            min_len = min(min_len, right - left + 1)

            for row in matrix:
                num_left = row[left]
                if nums[num_left] >= 0:
                    total += 1
                    nums[num_left] += 1

            left += 1

        right += 1

    if min_len == sys.maxsize:
        return -1
    else:
        return min_len

n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
k = int(input())
nums = list(map(int, input().split()))

counted_nums = count_numbers(nums)
result = get_result(matrix, k, counted_nums)
print(result)

C算法源码

#include <stdio.h>
#include <limits.h>
#include <math.h>

#define MAX_SIZE 1000

int n, m;
int matrix[MAX_SIZE][MAX_SIZE];

int k;
int cnts[MAX_SIZE] = {0};

int getResult() {
     int total = k;

    int minLen = INT_MAX;

     int l = 0;
    int r = 0;

     while (r < m) {
        for (int i = 0; i < n; i++) {
             int num = matrix[i][r];

                    if (cnts[num]-- > 0) {
                total--;
            }
        }

         while (total == 0) {
            minLen = (int) fmin(minLen, r - l + 1);

             for (int i = 0; i < n; i++) {
               
                int num = matrix[i][l];

             
                if (cnts[num]++ >= 0) {
                    total++;
                }
            }

             l++;
        }

        r++;
    }

    if (minLen == INT_MAX) {
        return -1;
    } else {
        return minLen;
    }
}

int main() {
    scanf("%d %d", &n, &m);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    scanf("%d", &k);

    for (int i = 0; i < k; i++) {
        int num;
        scanf("%d", &num);
        cnts[num]++;
    }

    printf("%d\n", getResult());

    return 0;
}

解题思路如下：