获取java中矩阵中连续出现k次的所有数字

这是带有更多详细信息的扩展，因为它标记为已关闭

我有一个大小为

nxn

的矩阵，现在我想找到一个连续出现k次的数字（顶部、底部、左侧、右侧、对角线）。如果找到数字，则返回它，否则返回0。如果有多个数字出现k次，则按升序返回所有数字

Example:

Given matrix:

3 5 3 9 5
4 3 2 1 8
9 4 3 1 9
8 4 7 6 4
1 2 5 9 1

Given k = 3

Output: number 3. Because only number 3 is occurring 3 times in diagonal way.

如何在Java编程中编写此逻辑。你能给我一些想法让我从那里开始吗？ 公共静态void main（字符串[]args）{ int[]m={{3,5,3,9,5}，{4,3,2,1,8}，{9,4,3,1,9}，{8,4,7,6,4}，{1,2,5,9,1}； int k=3

    List<Integer> result = process(m, k);
    System.out.println(result);
}

private static List<Integer> process(int[][] m, int k) {
    List<Integer> result = new ArrayList<>();
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < m.length; i++) {
        for (int j = 0; j < m.length; j++) {
            int count = map.getOrDefault(m[i][j], 0);
            map.put(m[i][j], count + 1);
        }
    }

    for (int number : map.keySet()) {
        if (map.get(number) >= k) {
            int consecutiveCount = getConsecutiveCount(number, m, k);
            if (consecutiveCount >= k) {
                result.add(number);
            }
        }
    }
    if (result.size() == 0) {
        result.add(-1);
    }
    return result;
}

private static int getConsecutiveCount(int number, int[][] m, int k) {
    return 0;
}

---

在不为您实际编写此代码的情况下，我将为您指出正确的方向。我的想法是将问题分成更小的问题，直到您只剩下一小部分

所以你可以这样想：

有

n*n

可能的起始位置。因此将其视为行和列上的一对外部嵌套循环：

y

从0到

n

和

x

从0到

n

对于每个起始位置

x，y

，序列有8个不同的方向。请将它们视为另外两个嵌套循环：

dx

over-1对1和

dy

over-1对1（但

dx

和

dy

不都是0）

---

对于任何起始位置

x

，

y

（其中

0

≤

x

您的上一个问题已关闭，因为您没有说明自己在尝试实施时遇到的问题。这需要更多的关注点，一个特定的问题。您基本上所做的就是发布您的作业。您可以编辑问题…在这些评论上方，在您的名片左侧有一个链接。您应该编辑LD问题，删除这个，或者删除这个，编辑你的旧问题。编辑可能是更好的解决方案，因为它会给你一个机会来删除它所接收的下限。仔细考虑你的编辑，因为看起来你在这个问题上犯了同样的错误。如果你不确定的话，请阅读。@ Dioxin、 我现在添加了使用DFS方法的代码，但在如何导航和获取计数方面遇到了困难。因此，DFS不是一种完全正确的方法，因为您没有真正的“结束”我将创建一个方法，该方法接受大小为K的数组，如果所有元素都相同，该数组将返回true。然后我将在大小为K的部分（左、下、右、左）中循环矩阵M使用

x=0

和

y=0

。甚至可以将每个矩阵扫描方向分解为自己的方法。我认为您不需要布尔矩阵，但可能需要一个

TreeMap

以“升序”存储数据我根据你的评论添加了我的尝试，但又卡住了，你能检查一下吗？实际上是

（n-k）*（n-k）

起始位置。否则，你会多次（向前和向后）找到相同的序列。如果你限制到这一点，那么向量只有（0,1），（1,0），（1,1），你永远不会“越界”这就是为什么你只想看八个方向中的四个方向

static boolean isSafe(int M[][], int row, int col, boolean visited[][], int number) {
    int ROW = M.length;
    int COL = M[0].length;
    return (row >= 0) && (row < ROW) && (col >= 0) && (col < COL) && (M[row][col] == number && !visited[row][col]);
}

static void DFS(int M[][], int row, int col, boolean visited[][], int number, int[] total) {
    int rowNbr[] = new int[] {-1, 1, 0, 1, 1};
    int colNbr[] = new int[] {0, 0, -1, 0, 1};

    visited[row][col] = true;
    total[0]++;
    for (int k = 0; k < rowNbr.length; ++k)
        if (isSafe(M, row + rowNbr[k], col + colNbr[k], visited, number)) {
            DFS(M, row + rowNbr[k], col + colNbr[k], visited, number, total);
        }
}

static int countIslands(int M[][], int number) {
    int ROW = M.length;
    int COL = M[0].length;
    boolean visited[][] = new boolean[ROW][COL];

    int count = 0;
    int[] total = {0};
    for (int i = 0; i < ROW; ++i)
        for (int j = 0; j < COL; ++j)
            if (M[i][j] == number && !visited[i][j]) // If a cell with
            { 
                DFS(M, i, j, visited, number, total);
                ++count;
            }

    return total[0];
}

// Driver method
public static void main(String[] args) throws java.lang.Exception {
    int M[][] = new int[][] { { 3, 5, 3, 9, 5 }, { 4, 3, 2, 1, 8 }, { 9, 4, 3, 1, 9 }, { 8, 4, 7, 6, 4 },
            { 1, 2, 5, 9, 1 } };
    List<Integer> result = process(M, 3);
    System.out.println(result);
}

private static List<Integer> process(int[][] m, int k) {
    List<Integer> result = new ArrayList<>();
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < m.length; i++) {
        for (int j = 0; j < m.length; j++) {
            int count = map.getOrDefault(m[i][j], 0);
            map.put(m[i][j], count + 1);
        }
    }
    System.out.println(map);

    for (int number : map.keySet()) {
        if (map.get(number) >= k) {
            int consecutiveCount = getConsecutiveCount(number, m, k);
            System.out.println(number + " : " + consecutiveCount);
            if (consecutiveCount >= k) {
                result.add(number);
            }
        }
    }
    if (result.size() == 0) {
        result.add(-1);
    }
    return result;
}

private static int getConsecutiveCount(int number, int[][] m, int k) {
    return countIslands(m, number);
}