巧用递归解决矩阵最大序列和问题

    public    class Matrix {
    /**
     * @param matrix  矩阵
     * @param dimension 代表 dimension 阶矩阵
     * @return 矩阵序列的最大值
     */
        private     static Integer getMaxSequetialSum(    int[] matrix,     int{
            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{
        // 查找 矩阵中位置为 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
    }
}