怒刷LeetCode的第22天（Java版）-CSDN博客

定义一个长度为N的数组queens，用于存储每行皇后所在的列数。
从第一行开始，依次遍历每一行。
在当前行，尝试将皇后放置在每一列，判断是否满足条件。
- 如果满足条件，则将该列标记为皇后所在的位置，并进入下一行进行递归。
- 如果不满足条件，则继续尝试下一列。
当遍历完最后一行时，说明找到了一组解决方案，计数器count加1。
回溯到上一行，撤销当前行的选择，继续尝试下一列。
当所有可能的选择都尝试完毕后，回溯结束。

在判断当前位置是否满足条件时，需要检查当前列、主对角线和副对角线上是否已经有其他皇后。如果存在冲突，则当前位置不可放置皇后。

最终，统计计数器count的值即为N皇后问题的不同解决方案数量。

class Solution {
    int count = 0; // 解决方案的数量
    
    public int totalNQueens(int n) {
        int[] queens = new int[n]; // 用来存储每行皇后所在的列数
        backtrack(queens, 0, n);
        return count;
    }
    
    private void backtrack(int[] queens, int row, int n) {
        if (row == n) { // 找到一个解决方案
            count++;
            return;
        }
        
        for (int col = 0; col < n; col++) {
            if (isValid(queens, row, col)) {
                queens[row] = col; // 将第row行的皇后放置在col列
                backtrack(queens, row + 1, n); // 继续放置下一行的皇后
            }
        }
    }
    
    private boolean isValid(int[] queens, int row, int col) {
        for (int i = 0; i < row; i++) {
            if (queens[i] == col || queens[i] - col == i - row || queens[i] - col == row - i) {
                // 判断是否在同一列或者在对角线上有其他皇后
                return false;
            }
        }
        return true;
    }
}

复杂度分析：

时间复杂度：该解法使用回溯算法，在每一行中需要遍历N个位置。因此，总共有N行，复杂度为 O(N^N)。但是，由于N的取值范围非常小（1<=N<=9），因此实际运行效率很高。
空间复杂度：该解法只需要一个长为N的数组来记录每个皇后所在的列数，因此空间复杂度为O(N)。

综上所述，该解法的时间复杂度和空间复杂度都较小，可以快速地找到N皇后问题的所有解决方案。

LeetCode运行结果：

方法二：基于位运算的回溯

位运算方法是一种巧妙的解决N皇后问题的算法，其基本思路如下：

使用一个整数变量来表示每一行、每一列以及两个对角线的占用情况。
- 对于每一行，整数的二进制表示中的某一位为1表示该位置已经被占用。
- 对于每一列，整数的二进制表示中的某一位为1表示该列已经有皇后。
- 对于主对角线（左上到右下方向）和副对角线（左下到右上方向），可以通过移位操作来表示。
在回溯过程中，逐行放置皇后，并更新整数变量的占用情况。
- 遍历当前行的每个位置，检查该位置是否可放置皇后。
- 如果该位置对应的列、主对角线和副对角线都没有被占用，则进行递归调用。
- 在递归调用之前，需要更新整数变量的占用情况，将相应的位置设置为已占用。
当递归到最后一行时，找到一个合法解法，计数加一。
- 在递归过程中，如果当前行达到了N，说明已经成功放置了N个皇后，找到一个合法解法，计数器加一。
通过递归回溯的方式，遍历所有可能的放置方式。

这种位运算方法可以有效地判断皇后的位置是否冲突，且在求解过程中不需要额外的数据结构来存储棋盘状态。通过位运算的方式，可以在常数时间内进行判断和更新占用情况，从而大大提高了算法的效率。

class Solution {
private int count;  // 解法计数器

    public int totalNQueens(int n) {
        // 初始化列、主对角线和副对角线的占用情况
        int cols = 0;
        int mainDiag = 0;
        int subDiag = 0;

        backtracking(0, cols, mainDiag, subDiag, n);
        
        return count;
    }

    private void backtracking(int row, int cols, int mainDiag, int subDiag, int n) {
        if (row == n) {
            count++;  // 找到一个解法
        } else {
            // 获取可放置皇后的位置
            int availablePos = ((1 << n) - 1) & (~(cols | mainDiag | subDiag));
            
            while (availablePos != 0) {
                // 取最低位的1，并清零其余位
                int position = availablePos & (-availablePos);
                
                // 继续下一行的回溯，更新占用情况
                backtracking(row + 1, cols | position, (mainDiag | position) << 1, (subDiag | position) >> 1, n);

                // 去掉最低位的1
                availablePos &= (availablePos - 1);
            }
        }
    }
}

复杂度分析：

时间复杂度：在位运算方法中，回溯的过程是一个递归操作。在每一行中，需要遍历当前行的每个位置，然后进行递归调用。在最坏情况下，每个位置都需要进行递归调用。因此，时间复杂度可以表示为O(N!)，其中N是皇后的数量。
空间复杂度：位运算方法的空间复杂度主要由递归调用时的内存消耗决定。在每个递归调用中，需要保存当前行、列、主对角线和副对角线的占用情况，以及递归过程中的其他临时变量。因此，空间复杂度可以表示为O(N)，其中N是皇后的数量。

综上所述，位运算方法解决N皇后问题的时间复杂度为O(N!)，空间复杂度为O(N)。该算法在较小的N值下可以快速求解N皇后问题，但随着N的增大，时间复杂度呈指数级增长，计算量会变得非常大。对于较大的N值，可能需要使用其他优化方法来降低计算的复杂度。

LeetCode运行结果：

第二题

题目来源

53. 最大子数组和 - 力扣（LeetCode）

题目内容

解决方法

方法一：动态规划

最大子数组和问题可以使用动态规划算法来解决。我们可以定义一个动态规划数组dp，其中dp[i]表示以第i个元素结尾的最大子数组和。

对于数组中的第i个元素，有两种情况：

将第i个元素加入到前面的子数组中：如果dp[i-1]大于0，说明前面的子数组和对于当前元素是有贡献的，所以将第i个元素加入到前面的子数组中会使得子数组和更大。因此，dp[i] = dp[i-1] + nums[i]。
第i个元素作为新的子数组的起点：如果dp[i-1]小于等于0，说明前面的子数组和对于当前元素没有贡献，所以舍弃前面的子数组，将第i个元素作为新的子数组的起点。因此，dp[i] = nums[i]。

通过以上的状态转移方程，我们可以计算出dp数组的每一个元素，然后找到其中的最大值maxSum，即得到最大子数组和。

最后，返回maxSum作为结果。

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n]; // dp[i]表示以第i个元素结尾的最大子数组和
        dp[0] = nums[0];
        int maxSum = dp[0];
        for (int i = 1; i < n; i++) {
            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
            maxSum = Math.max(maxSum, dp[i]);
        }
        return maxSum;
    }
}

复杂度分析：

时间复杂度分析：

遍历数组的过程中，需要计算每个位置上以该元素结尾的最大子数组和。这一步的时间复杂度是O(n)，其中n是数组的长度。
在计算每个位置上的最大子数组和时，只需要比较当前元素和当前元素加上前面子数组和的结果。这是一个常数时间操作。
因此，整个算法的时间复杂度是O(n)。

空间复杂度分析：

只需要使用一个动态规划数组dp来保存计算过程中的中间结果。所以空间复杂度是O(n)，其中n是数组的长度。
注意，这里的空间复杂度是指额外使用的空间，不包括输入数组本身的空间。

综上所述，最大子数组和问题的解决方案的时间复杂度是O(n)，空间复杂度是O(n)。

LeetCode运行结果：

方法二：分治法

除了动态规划之外，我们还可以使用分治法来解决最大子数组和问题。

分治法的基本思想是将问题划分为更小的子问题，并且递归地求解子问题。然后将子问题的结果合并起来得到原问题的结果。

对于最大子数组和问题，可以将数组划分为左右两个子数组，分别求解左子数组、右子数组和跨越中点的最大子数组和。最后将这三个结果中的最大值作为最终的结果。

具体步骤如下：

如果数组的长度为1，则最大子数组和就是数组中的唯一元素。
将数组等分为左右两部分，分别对左右子数组递归地求解最大子数组和，得到左子数组的最大子数组和leftSum和右子数组的最大子数组和rightSum。
计算跨越中点的最大子数组和crossSum：
- 从中点开始向左遍历，找到以中点为起点的最大子数组和leftCrossSum。
- 从中点的下一个位置开始向右遍历，找到以中点+1为起点的最大子数组和rightCrossSum。
- 跨越中点的最大子数组和crossSum = leftCrossSum + rightCrossSum。
返回leftSum、rightSum和crossSum中的最大值作为最终的结果。

class Solution {
    public int maxSubArray(int[] nums) {
        return maxSubArrayHelper(nums, 0, nums.length - 1);
    }

    private int maxSubArrayHelper(int[] nums, int left, int right) {
        if (left == right) {
            return nums[left];
        }

        int mid = (left + right) / 2;
        int leftSum = maxSubArrayHelper(nums, left, mid);
        int rightSum = maxSubArrayHelper(nums, mid + 1, right);
        int crossSum = maxCrossSum(nums, left, mid, right);

        return Math.max(Math.max(leftSum, rightSum), crossSum);
    }

    private int maxCrossSum(int[] nums, int left, int mid, int right) {
        int leftSum = Integer.MIN_VALUE;
        int sum = 0;
        for (int i = mid; i >= left; i--) {
            sum += nums[i];
            leftSum = Math.max(leftSum, sum);
        }

        int rightSum = Integer.MIN_VALUE;
        sum = 0;
        for (int i = mid + 1; i <= right; i++) {
            sum += nums[i];
            rightSum = Math.max(rightSum, sum);
        }

        return leftSum + rightSum;
    }
}

复杂度分析：

时间复杂度是O(n log n)，其中n是数组的长度。因为每次递归都将数组划分为两个子数组，并且需要线性时间来计算跨越中点的最大子数组和。总共有log n层递归，每层的时间复杂度是O(n)，所以总的时间复杂度是O(n log n)。
空间复杂度是O(log n)，其中n是数组的长度。每次递归都需要额外的空间来保存函数调用的上下文，递归深度是log n，所以空间复杂度是O(log n)。

LeetCode运行结果：

方法三：前缀和数组

使用前缀和数组解决最大子数组和问题的思路与算法如下：

首先，构建一个前缀和数组prefixSum，用于记录原始数组中每个位置之前所有元素的和。具体的操作如下：
- 初始化一个长度为n+1的前缀和数组prefixSum，其中n为原始数组的长度。
- 遍历原始数组nums，计算每个位置i之前所有元素的和，并将其存入prefixSum[i+1]中。即prefixSum[i+1] = nums[0] + nums[1] + ... + nums[i]。
- 这样，prefixSum数组中的第i个元素表示原始数组中前i个元素的和。
接下来，遍历前缀和数组prefixSum，同时维护两个变量maxSum和minPrefixSum，用于记录当前最大子数组和和当前最小前缀和。具体的操作如下：
- 初始化maxSum为负无穷大，minPrefixSum为0。
- 遍历前缀和数组prefixSum的每个元素prefixSum[i]：
  - 更新maxSum，取当前prefixSum[i]减去minPrefixSum的差值与maxSum的较大值。
  - 更新minPrefixSum，取当前prefixSum[i]与minPrefixSum的较小值。
最后，返回maxSum作为最大子数组和的结果。

这个算法的关键在于利用前缀和数组来计算子数组的和，避免了重复计算。通过维护最大子数组和和最小前缀和，可以在遍历过程中动态更新并得到最终结果。

public class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] prefixSum = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            prefixSum[i] = prefixSum[i - 1] + nums[i - 1];
        }

        int maxSum = Integer.MIN_VALUE;
        int minPrefixSum = 0;
        for (int i = 1; i <= n; i++) {
            maxSum = Math.max(maxSum, prefixSum[i] - minPrefixSum);
            minPrefixSum = Math.min(minPrefixSum, prefixSum[i]);
        }

        return maxSum;
    }
}

复杂度分析：

时间复杂度：构建前缀和数组需要遍历一次原始数组，时间复杂度为O(n)。然后在计算最大子数组和时，需要再次遍历一次前缀和数组，时间复杂度也是O(n)。因此，总体时间复杂度为O(n)。
空间复杂度：需要额外的空间存储前缀和数组，空间复杂度为O(n)。

综上所述，使用前缀和数组解决最大子数组和问题的时间复杂度为O(n)，空间复杂度为O(n)。

需要注意的是，虽然使用前缀和数组的时间复杂度与动态规划的时间复杂度相同，但两种方法的实现思路和具体代码略有不同。前缀和数组适用于需要频繁查询子数组和的场景，而动态规划适用于需要记录具体的子数组位置的场景。根据实际需求选择合适的方法。

LeetCode运行结果：

第三题

题目来源

54. 螺旋矩阵 - 力扣（LeetCode）

题目内容

解决方法

方法一：模拟遍历

思路与算法：

该问题可以通过模拟遍历的方式来解决。我们使用四个变量rowStart、rowEnd、colStart、colEnd来表示当前要遍历的子矩阵的边界位置。

初始化时，rowStart为0，rowEnd为矩阵的行数减1，colStart为0，colEnd为矩阵的列数减1。

然后，按照顺时针螺旋顺序遍历矩阵：

从左到右遍历当前行的元素，并将它们添加到结果列表中。
将rowStart加1，进入下一行。
从上到下遍历当前列的元素，并将它们添加到结果列表中。
将colEnd减1，进入下一列。
如果rowStart仍然小于等于rowEnd，则从右到左遍历当前行的元素，并将它们添加到结果列表中。
将rowEnd减1，进入上一行。
如果colStart仍然小于等于colEnd，则从下到上遍历当前列的元素，并将它们添加到结果列表中。
将colStart加1，进入下一列。
重复步骤1~8，直到遍历完所有的元素。
最后，返回结果列表。

通过以上的思路和算法，我们可以按照顺时针螺旋顺序遍历矩阵，并将元素添加到结果列表中。

class Solution {
 public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0) {
            return result;
        }

        int rowStart = 0, rowEnd = matrix.length - 1;
        int colStart = 0, colEnd = matrix[0].length - 1;

        while (rowStart <= rowEnd && colStart <= colEnd) {
            // Traverse right
            for (int i = colStart; i <= colEnd; i++) {
                result.add(matrix[rowStart][i]);
            }
            rowStart++;

            // Traverse down
            for (int i = rowStart; i <= rowEnd; i++) {
                result.add(matrix[i][colEnd]);
            }
            colEnd--;

            // Traverse left
            if (rowStart <= rowEnd) {
                for (int i = colEnd; i >= colStart; i--) {
                    result.add(matrix[rowEnd][i]);
                }
                rowEnd--;
            }

            // Traverse up
            if (colStart <= colEnd) {
                for (int i = rowEnd; i >= rowStart; i--) {
                    result.add(matrix[i][colStart]);
                }
                colStart++;
            }
        }

        return result;
    }

}

复杂度分析：

设矩阵的行数为m，列数为n。

时间复杂度：遍历矩阵中的每个元素需要O(m*n)的时间复杂度。
空间复杂度：除了存储结果的列表外，我们并没有使用额外的空间，因此空间复杂度为O(1)。

综上所述，该算法的时间复杂度为O(m*n)，空间复杂度为O(1)。

LeetCode运行结果：

方法二：递归

除了模拟遍历的方法，还可以使用递归解决螺旋矩阵问题。

该方法通过递归地遍历螺旋路径，在每一层递归中处理当前子矩阵的四条边。递归函数spiralOrderHelper接受子矩阵的边界索引和结果列表，然后按照顺时针螺旋顺序遍历矩阵并将元素添加到结果列表中。

class Solution {
    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0) {
            return result;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        spiralOrderHelper(matrix, 0, m - 1, 0, n - 1, result);
        return result;
    }
    
    private static void spiralOrderHelper(int[][] matrix, int rowStart, int rowEnd, int colStart, int colEnd, List<Integer> result) {
        if (rowStart > rowEnd || colStart > colEnd) {
            return;
        }
        
        // Traverse right
        for (int i = colStart; i <= colEnd; i++) {
            result.add(matrix[rowStart][i]);
        }
        
        // Traverse down
        for (int i = rowStart + 1; i <= rowEnd; i++) {
            result.add(matrix[i][colEnd]);
        }
        
        // Traverse left
        if (rowStart < rowEnd) {
            for (int i = colEnd - 1; i >= colStart; i--) {
                result.add(matrix[rowEnd][i]);
            }
        }
        
        // Traverse up
        if (colStart < colEnd) {
            for (int i = rowEnd - 1; i > rowStart; i--) {
                result.add(matrix[i][colStart]);
            }
        }
        
        spiralOrderHelper(matrix, rowStart + 1, rowEnd - 1, colStart + 1, colEnd - 1, result);
    }
}

复杂度分析：

假设矩阵的大小是m × n（行数为m，列数为n），我们来分析一下递归解法的时间复杂度和空间复杂度。

时间复杂度分析：递归函数的时间复杂度主要取决于两个因素：

每一层递归的时间复杂度：在每一层递归中，需要遍历边界上的元素，这个操作的时间复杂度是O(n+m)。因为每个元素需要访问一次，且没有重复访问。
递归的层数：递归的层数取决于矩阵的大小，即m和n的较小值。这是因为每一次递归都会缩小矩阵的规模，直到最后只剩下一个元素或者没有元素。

所以，递归解法的总的时间复杂度可以表示为O((n+m) * min(m, n))，其中n和m分别表示矩阵的列数和行数。

空间复杂度分析：递归函数的空间复杂度主要取决于两个因素：

递归调用栈的大小：每一层递归都会在调用栈中占用一定的空间，具体的大小取决于递归的层数。由上面分析可知，递归的层数是O(min(m, n))。
存储结果的空间：递归函数需要返回一个螺旋遍历的结果，这个结果列表的大小与矩阵中的元素个数相同，即m * n。

因此，递归解法的总的空间复杂度可以表示为O(m * n + min(m, n))。

综上所述，使用递归解决螺旋矩阵问题的时间复杂度是 O((n+m) * min(m, n))，空间复杂度是 O(m * n + min(m, n))。在矩阵较大时，递归解法可能会造成栈溢出或者额外的空间开销较大，因此在实际应用中需要谨慎使用。

LeetCode运行结果：

方法三：方向转换法

这种方法基于对螺旋矩阵的特性进行分析，通过不断改变遍历方向来遍历整个矩阵。具体步骤如下：

定义4个边界：上边界、下边界、左边界、右边界。
初始化当前位置为(0, 0)，遍历方向为向右。
当遍历方向向右时，先向右遍历直到到达右边界，然后将上边界下移一行，遍历方向转为向下。
当遍历方向向下时，先向下遍历直到到达下边界，然后将右边界左移一列，遍历方向转为向左。
当遍历方向向左时，先向左遍历直到到达左边界，然后将下边界上移一行，遍历方向转为向上。
当遍历方向向上时，先向上遍历直到到达上边界，然后将左边界右移一列，遍历方向转为向右。
重复上述步骤，直到遍历完整个矩阵。

class Solution {
    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }

        int m = matrix.length; // 行数
        int n = matrix[0].length; // 列数
        int top = 0, bottom = m - 1, left = 0, right = n - 1;
        int direction = 0; // 0表示向右, 1表示向下, 2表示向左, 3表示向上

        while (top <= bottom && left <= right) {
            if (direction == 0) { // 向右遍历
                for (int i = left; i <= right; i++) {
                    result.add(matrix[top][i]);
                }
                top++; // 上边界下移一行
            } else if (direction == 1) { // 向下遍历
                for (int i = top; i <= bottom; i++) {
                    result.add(matrix[i][right]);
                }
                right--; // 右边界左移一列
            } else if (direction == 2) { // 向左遍历
                for (int i = right; i >= left; i--) {
                    result.add(matrix[bottom][i]);
                }
                bottom--; // 下边界上移一行
            } else if (direction == 3) { // 向上遍历
                for (int i = bottom; i >= top; i--) {
                    result.add(matrix[i][left]);
                }
                left++; // 左边界右移一列
            }

            direction = (direction + 1) % 4; // 改变遍历方向
        }

        return result;
    }
}

复杂度分析：

这种方法只需要遍历一次矩阵，时间复杂度为O(m * n)，空间复杂度为O(1)。

LeetCode运行结果：

方法四：螺旋填数法

这种方法实际上是构造螺旋矩阵的过程，可以直接得到螺旋遍历的结果。具体步骤如下：

定义4个边界：上边界、下边界、左边界、右边界。
初始化当前数字为1，遍历方向为向右。
当遍历方向向右时，从左到右填充当前行的所有元素，并将上边界下移一行。
当遍历方向向下时，从上到下填充当前列的所有元素，并将右边界左移一列。
当遍历方向向左时，从右到左填充当前行的所有元素，并将下边界上移一行。
当遍历方向向上时，从下到上填充当前列的所有元素，并将左边界右移一列。
重复上述步骤，直到填充完整个矩阵。

class Solution {
    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }

        int m = matrix.length; // 行数
        int n = matrix[0].length; // 列数
        int top = 0, bottom = m - 1, left = 0, right = n - 1;
        int numElements = m * n;
        int num = 1;

        while (num <= numElements) {
            // 从左到右填充当前行的元素
            for (int i = left; i <= right && num <= numElements; i++) {
                result.add(matrix[top][i]);
                num++;
            }
            top++; // 上边界下移一行

            // 从上到下填充当前列的元素
            for (int i = top; i <= bottom && num <= numElements; i++) {
                result.add(matrix[i][right]);
                num++;
            }
            right--; // 右边界左移一列

            // 从右到左填充当前行的元素
            for (int i = right; i >= left && num <= numElements; i--) {
                result.add(matrix[bottom][i]);
                num++;
            }
            bottom--; // 下边界上移一行

            // 从下到上填充当前列的元素
            for (int i = bottom; i >= top && num <= numElements; i--) {
                result.add(matrix[i][left]);
                num++;
            }
            left++; // 左边界右移一列
        }

        return result;
    }
}

复杂度分析：

这种方法也只需要遍历一次矩阵，时间复杂度为O(m * n)，空间复杂度为O(1)。

LeetCode运行结果：