如何在矩阵 Java 中找到 2x3 模式

Question

这个算法让我难住了。 我是数据结构和算法的新手，我了解代码需要做什么，但无法全神贯注于如何实际编码。

问题如下：

确定矩阵是否包含金票。 一张金票由 6 个大写字母“G”组成，其中三对 G 位于彼此的正上方，如下所示。 请注意，我省略了单引号以提高可读性。

G G
G G
G G

例如，

[A b - - C dm]
[- GGZ GG -]

[H o - r G G D] 这个矩阵返回真

[H o - r G G D]

例如，

[R g G - C dm W]
[- GG Z G G - r] 这个矩阵返回 false

[o G G G r G G D]因为G不在指定的position

[S t C - GG a -] 相对

矩阵应该是“矩形”的，这意味着所有行都应该有相同数量的元素。 如果不是这种情况，则应抛出 IllegalArgumentException。

这是我写的：

public static boolean goldenTicket(char[][] matrix) {
    if (matrix == null) return false;
    if (matrix.length == 0) return false;

    char char1, char2;
    int matchCount = 0;
    int indexOne = 0, indexTwo = 0, prevIndex1 = 0,prevIndex2 = 0;
    int rows = matrix.length;
    int columns = matrix[0].length;


    for (int i = 0; i < rows; i++) {
        if (matrix[i].length != columns)
            throw new IllegalArgumentException("Length of row doesn't match");
        if (matrix[i].length == 0) return false;
        if (matchCount == 3) return true;

        for (int j = 1; j < columns; j++) {
            if (matrix[i][j] == 'G' && matrix[i][j - 1] == 'G') {
                if (prevIndex1 == 0 && prevIndex2 == 0) {
                    indexOne = j - 1;
                    indexTwo = j;
                    matchCount++;
                } else {
                    prevIndex1 = j - 1;
                    prevIndex2 = j;
                    matchCount++;
                }
            }
        }

        if (prevIndex1 == indexOne && prevIndex2 == indexTwo) {
            matchCount++;
        }
    }
    return false;
}

但是，问题是代码通过了上面的示例一和示例二，而不是仅通过了示例 1。我已经交了作业，只通过了 24/25 测试，我真的很想了解它应该如何工作并且也许是一种更好的编码方式以供将来参考。

提前致谢！

Answer 1

它可以用O(ncol*nrow)来解决，其中ncol是列数， nrow是行数。

您应该生成一个与原始矩阵具有相同行和列的矩阵，并且对于每个项目，您考虑一对数字，其中第一个元素代表连续G的数量，包括该项目在行中，第二个元素代表连续的数量G将此项目包括在列中。

为了填充这个矩阵（我将其命名为onlyGMatrix ）我们检查项目(i,j)是否为G ，如果不是我们简单地放置对(0,0)否则对于i>0 and j>0我们放置min {onlyGMatrix(i-1,j)[0], onlyGMatrix(i,j-1)[0]} + 1作为第一个元素和min {onlyGMatrix(i-1,j)[1], onlyGMatrix(i,j-1)[1]} + 1作为第二个元素。

使用您的第一个矩阵，我们将达到以下onlyGMatrix ：

(0,0) (0,0) (0,0) (0,0) (0,0) (0,0) (0,0)
(0,0) (0,0) (0,0) (0,0) (1,1) (2,1) (0,0)
(0,0) (0,0) (0,0) (0,0) (2,1) (2,2) (0,0)
(0,0) (0,0) (0,0) (0,0) (3,1) (3,2) (0,0)

对于您的第二个矩阵，我们将有：

(0,0) (0,0) (1,1) (0,0) (0,0) (0,0) (0,0) (0,0)
(0,0) (1,1) (2,2) (0,0) (1,1) (2,1) (0,0) (0,0)
(0,0) (1,2) (2,3) (3,1) (0,0) (1,2) (2,1) (0,0)
(0,0) (0,0) (0,0) (0,0) (1,1) (2,1) (0,0) (0,0)

现在，当您在构建此onlyGMatrix时看到对(3,2)时，您的算法将成功结束，并且如果您到达矩阵的最后一个元素并且您没有看到这对，那么您应该返回 false。

Answer 2

这是分而治之可以帮助简化代码的问题类型。

任务是在一个更大的矩阵中找到一个字母“G”的2×3矩阵。

因此，我们编写了一种方法来检查更大矩阵中的每个 2 x 3 矩阵。

这是我的一项测试的结果。

[a, G, G, a]
[a, G, G, a]
[a, G, a, a]
[a, a, a, a]
false
[a, G, G, a]
[a, G, G, a]
[a, G, G, a]
[a, a, a, a]
true
[a, a, a, a]
[a, a, G, G]
[a, a, G, G]
[a, a, G, G]
true

我写了两个方法。

goldenTicket方法检查矩阵是否为 null，是否小于 2 x 3 矩阵，或者列长度是否相同。 最后一个代码块通过矩阵寻找金票。

isTicket方法检查矩阵的当前 2 x 3 部分是否全部由“G”字母组成。

将代码分解为两个方法使每个方法更小且更易于阅读，并且在某种程度上隐藏了需要 4 个嵌套for循环才能正确解决任务的事实。

这是完整的可运行代码。

import java.lang.reflect.Array;
import java.util.Arrays;

public class GoldenTicketExample {

    public static void main(String[] args) {
        char[][] matrix1 = { { 'a', 'G', 'G', 'a' }, { 'a', 'G', 'G', 'a' },
                { 'a', 'G', 'a', 'a' }, { 'a', 'a', 'a', 'a' } };
        displayOutput(matrix1);
        char[][] matrix2 = { { 'a', 'G', 'G', 'a' }, { 'a', 'G', 'G', 'a' },
                { 'a', 'G', 'G', 'a' }, { 'a', 'a', 'a', 'a' } };
        displayOutput(matrix2);
        char[][] matrix3 = { { 'a', 'a', 'a', 'a' }, { 'a', 'a', 'G', 'G' },
                { 'a', 'a', 'G', 'G' }, { 'a', 'a', 'G', 'G' } };
        displayOutput(matrix3);
    }

    private static void displayOutput(char[][] matrix) {
        for (char[] row : matrix) {
            System.out.println(Arrays.toString(row));
        }
        System.out.println(goldenTicket(matrix));
    }

    public static boolean goldenTicket(char[][] matrix) {
        if (matrix == null) {
            return false;
        }
        if (matrix.length < 3) {
            return false;
        }

        int columns = matrix[0].length;
        if (columns < 2) {
            return false;
        }

        for (int row = 1; row < matrix.length; row++) {
            if (matrix[row].length != columns) {
                throw new IllegalArgumentException(
                        "Length of row doesn't match");
            }
        }

        for (int row = 0; row < matrix.length - 2; row++) {
            for (int column = 0; column < matrix[row].length - 1; column++) {
                if (isTicket(matrix, row, column)) {
                    return true;
                }
            }
        }

        return false;
    }

    private static boolean isTicket(char[][] matrix, int row, int column) {
        for (int r = row; r < row + 3; r++) {
            for (int c = column; c < column + 2; c++) {
                if (matrix[r][c] != 'G') {
                    return false;
                }
            }
        }

        return true;
    }

}