由网友(微笑是我的伪装)分享简介：这是不是一门功课。我在编程的初学者，也这是我的第一篇文章在这里 - 请大家多多包涵。 This is NOT a homework. I'm a beginner in programming, and also this is my first post here - please bear with me. 我...

这是不是一门功课。我在编程的初学者，也这是我的第一篇文章在这里 - 请大家多多包涵。

This is NOT a homework. I'm a beginner in programming, and also this is my first post here - please bear with me.

我是不是能找到这里发表类似的问题。

I was not able to find similar questions posted here.

在一个初学者的书，我发现了以下问题：

In a beginner's book, I found the following issue:

# Find the biggest area of adjacent numbers in this matrix:
1 3 2 2 2 4
3 3 3 2 4 4
4 3 1 2 3 3 #--> 13 times '3'
4 3 1 3 3 1
4 3 3 3 1 1

这里的code我到目前为止，使用DFS实现从的http://www.algolist.net/Algorithms/Graph_algorithms/Undirected/Depth-first_search.有幻数无处不在，这些方法是公共静态，等等 - 我正打算解决这些事情后，该算法的工作...

Here's the code I have so far, using the DFS implementation from http://www.algolist.net/Algorithms/Graph_algorithms/Undirected/Depth-first_search. There are 'magic numbers' everywhere, and the methods are 'public static', etc. - I was intending to fix these things after the algorithm worked...

public class AdjacentAreaInMatrix {
    /*
     * Enums for the state of the Nodes, for use in DFS/BFS
     */
    private enum NodeState {
        Visited, InProgress, Unvisited
    }; 

    /*
     * These 2 'magic' numbers come from the hardcoded 'matrix' below,
     * cause it has 5 rows and 6 columns
     */
    public static final int ROWSCOUNT = 5;
    public static final int COLUMNSCOUNT = 6;

    /*
     * Two variables for counting the maximum sequence 
     * of numbers (as required by the problem definition)
     */
    private static int tempElementsCount = 0;
    private static int maxElementsCount = 1; // except if the matrix is empty, then it should be 0

    /*
     * The hardcoded matrix
     */
    private static final int[][] matrix = new int[][] { 
            { 1, 3, 2, 2, 2, 4 },
            { 3, 3, 3, 2, 4, 4 }, 
            { 4, 3, 1, 2, 3, 3 },
            { 4, 3, 1, 3, 3, 1 }, 
            { 4, 3, 3, 3, 1, 1 } };

    /* 
     * Create an auxiliary matrix 'state' to implement DFS. 
     * Initialize the whole matrix as 'unvisited' and
     * start DFS at the first element of the matrix
     */
    public static void DFS() {
        NodeState state[][] = new NodeState[ROWSCOUNT][COLUMNSCOUNT];
        // clear the state of the matrix
        for (int i = 0; i LT ROWSCOUNT; i++) {
            for (int j = 0; j LT COLUMNSCOUNT; j++) {
                state[i][j] = NodeState.Unvisited;
            }
        }
        runDFS(0, 0, state);    
    }

    /*
     * Using the auxiliary matrix "state[][]", use DFS to traverse the
     * 'real' matrix[][] 
     */
    public static void runDFS(int i, int j, NodeState state[][]) {
        state[i][j] = NodeState.InProgress;
        // traverse the whole matrix state[][] and recursively run runDFS() from the needed elements. 
        for (int rows = 0; rows LT ROWSCOUNT; rows++) {
            for (int columns = 0; columns LT COLUMNSCOUNT; columns++) {
                /*
                 * ----------------------------------------------------------------------
                 * For the logic in the 'if' statement regarding the adjacent elements:
                 * i0j0 i1j0 i1j0
                 * i0j1 i1j1 i2j1
                 * i0j2 i1j2 i2j2
                 * It uses the thing, that the sum of (i+j) for the coordinates of
                 * the elements above, below, on the left and on the right of i1j1
                 * are exactly +1/-1 of the sum of the coordinates of i1j1
                 * -> i1j2 to 1+2 = 3 
                 * -> i2j1 to 1+2 = 3 
                 * -> i1j1 to 1+1 = 2 (the current element) -> matrix[i][j] 
                 * -> i1j0 to 1+0 = 1 
                 * -> i0j1 to 1+0 = 1 
                 * ----------------------------------------------------------------------
                 */
                if ((matrix[i][j] == matrix[rows][columns]) // if the values are equal
                        && ((((i+j) - (rows + columns)) == 1) || (((i+j) - (rows + columns)) == -1))// and if the element is adjacent
                        && (state[rows][columns] == NodeState.Unvisited)) { // and if the element is still not visited
                    tempElementsCount++;
                    if (tempElementsCount > maxElementsCount) {
                        maxElementsCount = tempElementsCount;
                    }
                    runDFS(rows, columns, state); // recursively run DFS for each element, that "isEdge"
                } else {
                    // if the elements aren't [adjacent, equal and not visited], start the count again from '0'
                    tempElementsCount = 0;  
                }
            }
        }
        state[i][j] = NodeState.Visited;
    }

    public static void go() {
        AdjacentAreaInMatrix.DFS();
        System.out.println(maxElementsCount);
    }
}  

调试了好几天，每调试会话的code变得更加复杂后...任何帮助将AP preciated。先谢谢了。

After debugging it for several days, with every debugging session the code becomes more complicated...any help will be appreciated. Thanks in advance.

推荐答案

我认为这个问题是你每次都重新设置tempElementsCount。试想一下，你的code将工作在给定矩阵上，你会看到你在runDFS（）方法，你总是开始搜索与元素（0，0）该条款的话会是假的，所以你重置tempElementsCount之前，你可以继续搜索与其他（也可能是相邻）的元素。希望我很清楚......

I think the problem is that you are resetting the tempElementsCount every time. Just imagine how your code would work on the given matrix and you'll see that you in the runDFS() method you always start the search with element (0, 0) for which the if clause will be false, so you reset tempElementsCount before you could continue the search with the other (and probably adjacent) elements. Hope I was clear enough...