一招教你巧用遞歸解決矩陣最大序列和問題

以前同事問了一道須要點腦洞的算法題，我以爲蠻有意思的，思路可能會給你們帶來一些啓發，在此記錄一下

題目

現有一個元素僅爲 0，1 的 n 階矩陣，求連續相鄰(水平或垂直，不能有環)值爲 1 的元素組成的序列和的最大值。假設有以下矩陣

則此矩陣連續相鄰值爲 1 的元素組成的序列和分別爲 4， 3，（如圖示），可知這個矩陣符合條件的序列和的最大值爲 4

解題思路

要算序列和的最大值，咱們能夠先找出全部可能的序列，天然就找到了序列和的最大值,那怎麼找這些序列呢？首先咱們發現，每一個序列的起點和終點必然是 1，咱們能夠遍歷矩陣的每個元素，若是元素值爲 1，則將其做爲序列的起點開始查找全部以這個元素爲起點的序列，咱們知道序列是能夠向垂直和水平方向延伸的，因此咱們能夠以這個元素爲起點，查找它的上下左右值爲 1 的元素，再以找到的這些元素爲起點，繼續在元素的上下左右查找值爲 1 的元素，以此類推（遞歸），若是找不到符合條件的值，則序列終止，在遍歷過程當中保存每條序列遍歷的元素，便可求得每條符合條件的序列，從而求得序列和的最大值

文字說得有點繞，接下來咱們就以查找以下矩陣的最大序列和爲例來詳細看一下如何查找最大序列和

1. 從左到右，從上到下遍歷全部值爲 1 的元素，第一個符合條件的元素在右上角，因此以這個元素爲起點來查找序列   

2. 以這個元素爲起點，查找這個元素上下左右爲值爲 1 的元素，發現只有這個元素下面的元素符合條件 

3. 再以這個元素爲起點查找這個元素先後左右值爲 1 的元素，能夠看到這個元素的上，左元素值爲 1，左邊的元素顯然符合條件，而上面的元素因爲是當前正在遍歷序列中遍歷過的元素，因此不符合條件（假設上面的元素符合條件，會發生什麼?接下來會尋找以上面元素爲起始點的序列，又回到了第一步，陷入無限循環，因此元素的下一個值爲 1 的元素不能是當前正在遍歷的序列中的元素!，這一點是解題的關鍵，務必要注意!）由此可知此時符合條件的元素以下紅圈所示

4. 再尋找此元素上下左右都爲 1 的元素，能夠看到這個元素的左右下的元素都爲 1，根據上一步的分析可知，右元素是當前正在遍歷序列中已遍歷過的元素，因此不符合條件，那麼只剩下左，下元素符合條件

5. 再次尋找這兩個元素上下左右皆爲 1 的元素，可知符合條件的元素爲步驟 3 中的紅框元素，因爲此元素是當前正在遍歷序列中已遍歷過的元素，因此不符合條件，序列的遍歷到此終止，至此咱們能夠知道，從右上角元素爲起點的序列和的最大值爲 4 ,鏈接遍歷過的元素，如圖示

或

6. 同理接下來再按照以上的步驟依次遍歷剩餘的值爲 1 的元素，可知以這些元素爲起點的序列和的最大值分別爲 4, 3, 3, 4（以下圖）

7. 綜上可知，此矩陣連續相鄰值爲 1 的元素的序列和的最大值爲 4

代碼實現

好了，知道了解題思路，如今咱們來看下代碼該如何實現，首先咱們要用一個數據結構來表示矩陣，顯然矩陣用數組表示很合適,這裏咱們用一維數組來表示矩陣,Java 代碼以下

public class Matrix {
    /**
     * @param matrix  矩陣
     * @param dimension 表明 dimension 階矩陣
     * @return 矩陣序列的最大值
     */
    private static Integer getMaxSequetialSum(int[] matrix, int dimension) {
        int count = matrix.length;      // 矩陣的元素個數
        int maxSequentialSum = 0;       // 矩陣序列的最大值
        // 逐個遍歷元素
        for (int index = 0; index < count; index++) {
            int elementValue = matrix[index];
            // 若是當前元素爲1，則以此元素爲起點，查找以此元素爲起點的序列的和的最大值
            if (elementValue == 1) {
                // 記錄如下標爲 index 的元素爲起點的序列遍歷過的元素位置
                Set<Integer> traverseElementSet = new HashSet<>();
                traverseElementSet.add(index);
                // 如下標值爲 index 的元素爲起點的序列的最大值
                int currentSequetialSum = getCurrentVerticeSequetialSum(matrix, traverseElementSet, index, dimension);
                maxSequentialSum = Math.max(maxSequentialSum, currentSequetialSum);
            }
        }
        return maxSequentialSum;
    }

    /**
     * @param matrix  矩陣
     * @param traverseElementSet 序列中已遍歷過的元素的位置
     * @param index     元素的位置，序列的起點
     * @param dimension dimension 階矩陣
     * @return 以位置爲 index 的元素爲起點的序列的最大值
     */
    private static Integer getCurrentVerticeSequetialSum(int[] matrix, Set<Integer> traverseElementSet, int index, int dimension) {
        // 查找 矩陣中位置爲 index 的元素上下左右元素對應的位置
        int left = index - 1;
        int right = index + 1;
        int up = index - dimension;
        int down = index + dimension;

        // 以左元素爲起點的序列的最大值
        int leftIndexSum = 0;

        // 以右元素爲起點的序列的最大值
        int rightIndexSum = 0;

        // 以上元素爲起點的序列的最大值
        int upIndexSum = 0;

        // 如下元素爲起點的序列的最大值
        int downIndexSum = 0;

        /**
         * 如下四個 if else 旨在檢查每個元素位置的有效性，值必須爲 1
         * 須要注意的是元素不能是序列已遍歷過的元素！
         * 若是上下左右元素不合法，則序列終止，打點此遍歷序列的元素和
         */

        if (left >= 0 && matrix[left] == 1 && !traverseElementSet.contains(left)) {
            Set<Integer> leftTraverseElementSet = new HashSet<>(traverseElementSet);
            leftTraverseElementSet.add(left);
            leftIndexSum = getCurrentVerticeSequetialSum(matrix, leftTraverseElementSet, left, dimension);
        } else {
            leftIndexSum = traverseElementSet.size();
        }

        // 右元素必須與位置爲index的元素在同一行上
        if (right / dimension == index / dimension && matrix[right] == 1 && !traverseElementSet.contains(right)) {
            traverseElementSet.add(right);
            Set<Integer> rightTraverseElementSet = new HashSet<>(traverseElementSet);
            rightTraverseElementSet.add(right);
            rightIndexSum = getCurrentVerticeSequetialSum(matrix, rightTraverseElementSet, right, dimension);
        } else {
            rightIndexSum = traverseElementSet.size();
        }

        if (up >= 0 && matrix[up] == 1 && !traverseElementSet.contains(up)) {
            Set<Integer> upTraverseElementSet = new HashSet<>(traverseElementSet);
            upTraverseElementSet.add(up);
            upIndexSum = getCurrentVerticeSequetialSum(matrix, upTraverseElementSet, up, dimension);
        } else {
            upIndexSum = traverseElementSet.size();
        }

        if (down < matrix.length && matrix[down] == 1 && !traverseElementSet.contains(down)) {
            Set<Integer> downTraverseElementSet = new HashSet<>(traverseElementSet);
            downTraverseElementSet.add(down);
            downIndexSum = getCurrentVerticeSequetialSum(matrix, downTraverseElementSet, down, dimension);
        } else {
            downIndexSum = traverseElementSet.size();
        }

        // 查找以位置爲 index 的元素爲起點各向上下左右延伸的序列的最大值
        return Collections.max(Arrays.asList(leftIndexSum, rightIndexSum, upIndexSum, downIndexSum));
    }

    public static void main(String[] args) {
        // 初始化矩陣,假設此矩陣爲 5 x 5 矩陣
        int[] matrix1 = {
                0,0,0,0,1,
                0,0,1,1,1,
                0,0,0,1,0,
                0,0,0,0,0,
        };
        int max = Matrix.getMaxSequetialSum(matrix1, 5);
        System.out.println(max);  // 打印4

        int[] matrix2 = {
                0,0,0,0,1,
                0,0,1,1,1,
                0,0,1,1,0,
                0,0,0,0,0,
        };
        max = Matrix.getMaxSequetialSum(matrix2, 5);
        System.out.println(max);  // 打印6
    }
}

##時間複雜度與空間複雜度分析

任何算法，若是不談時間複雜度與空間複雜度都是耍流氓，接下來咱們看下以上解法的時間複雜度和空間複雜度。首先來看空間複雜，因爲在在遍歷過程當中咱們用了記錄遍歷序列元素位置的 traverseElementSet，因此空間複雜度顯然是 O(n)，這道題用了遞歸，時間複雜度確實挺複雜的，也比較考驗程序員的水平，直觀上看不出來，那咱們看下怎麼推導，咱們用 f(n) 來表示以位置爲 n 的元素爲起點的序列和的計算次數，從以上的推導可知，只要計算出以此元素的上下左右元素爲起點的序列和的最大值，也天然知道了 f(n)。即計算以位置 n 爲起點的序列和次數換算成計算以此元素的上下左右元素爲起點的序列和的次數

f(n) = f(左) + f(右) + f(上) + f(下)

仔細考慮一下可知以上下左右四個元素爲起點的序列和的計算次數能夠認爲是同樣的從而有 f(n) = 4f(左) 假設矩陣元素個數爲N,則f(n) = 4N因爲有 N 個元素，因此可知總的時間複雜度爲 O(4N²),即 O(n²)，若是你有更優的時間複雜度解法，歡迎一塊兒探討！

總結

這道題乍一看確實沒什麼頭緒，沒法像反轉二叉樹那樣比較容易地看出使用遞歸的思路去解決，咱們須要耐心地去分析，學會把問題分解，分解思路以下：求連續序列的最大值轉化爲如何求全部的序列 ----> 觀察到序列起點的元素必須是 1 ----> 想到如何找尋以值爲 1 的元素爲起點的全部序列 ----> 只要找到以這個元素上下左右值爲 1 的元素爲起點的全部序列和 ----> 再以上下左右元素值爲 1 的元素爲起點遞歸找尋以它們各自的上下左右值爲 1 的元素爲起點的全部序列 ----> 找到全部的序列後天然就找到了最大序列。

轉載自公衆號：碼海