算法工程师重生之第二天（长度最小的子数组螺旋矩阵II 区间和开发商购买土地总结）

参考文献代码随想录

一、长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的

子数组

[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

进阶：

如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

暴力

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        # 暴力思路: 2层循环寻找和大于等于target的，然后并计算长度
        # 定义一个临时变量result存放的是和大于等于target的最小长度
        result = float('inf')
        for i in range(len(nums)):  # 先从每一个元素开始找
            tmpSum = 0 # 临时存放每个长度之和  
            for j in range(i, len(nums)):  # 找这个元素后面的元素
                tmpSum += nums[j]
                if tmpSum >= target:  # 一旦找到，此时必定是当前最小的长度
                    result = min(result, j - i + 1)
                    break  # 调出循环
        if result == float('inf'):
            return 0
        return result

滑动窗口（双指针）

使用2个指针，一个慢指针（就是更新的值没有另外一个指针快），一个快指针（同理），还需要定义一个变量，接受对应长度的和，result变量统计最小长度之和大于等于target的，然后while循环，那么这个while循环的条件是什么呢？是快指针小于数组的长度，那为什么不判断慢指针呢？因为快指针比慢指针更快到达数组的长度，在while循环，统计和，然后判断此时的和是否大于等于target，问题来了？是使用if呢，还是while呢，这里举一个例子：假设target = 3，数组为[2,3,1,2,4,3]，当统计到3,1,2,4的时候，此时是大于target的，那么当满足条件后，移动慢指针时，剩下的还是大于等于target，所以使用while判读，条件成立后，对应的长度=快-慢+1，然后先对和做减法，然后在移动，为什么？因为如果你先移动慢指针，那么在对和做减法的话，就会出错。

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        # 滑动窗口: 双指针寻找和大于等于target的，然后并计算长度，
        # 定义一个临时变量result存放的是和大于等于target的最小长度
        result = float('inf')
        slow = 0
        fast = 0
        tmpSum = 0 # 记录临时对应长度的和
        while fast < len(nums):
            tmpSum += nums[fast]
            while tmpSum >= target:  # 为什么要使用while，因为当你移动慢指针的时候，结果还可能大于等于target
                result = min(result, fast - slow + 1)
                tmpSum -= nums[slow] # 把慢指针向后移，那么这个和就要减去
                slow += 1
            fast += 1
        if result == float('inf'):
            return 0
        return result

二、螺旋矩阵 II

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

1 <= n <= 20

思路

总体思路是创建一个 n x n 的矩阵并按螺旋顺序填充数字。步骤如下：（方向的控制，只有遇到超出边界的时候，才调整方向（难点：如何调整方向））

初始化：创建一个 n x n 的矩阵，所有位置初始化为 0。定义四个方向（右、下、左、上）来控制填充顺序。
填充逻辑：
- 从矩阵的起始位置（通常是 (0, 0)）开始填充数字。
- 根据当前方向（右、下、左、上）填充下一个位置的数字。
- 如果遇到矩阵边界或已填充的位置，改变方向。
- 重复这个过程，直到矩阵完全填充。
方向控制：使用方向数组和索引来控制填充方向。当无法继续沿当前方向填充时，更新方向索引以切换方向。

这种方法确保了螺旋填充的正确性，逐步向内完成整个矩阵。

class Solution(object):
    def generateMatrix(self, n):
        matrix = [[0] * n for _ in range(n)]
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # 右、下、左、上
        x, y = 0, 0
        direction_index = 0
        for num in range(1, n * n + 1):  # num代表的是螺旋矩阵的每个元素
            matrix[x][y] = num
            next_x, next_y = x + directions[direction_index][0], y + directions[direction_index][1]  # 向某个方向填充(右、下、左、上)
            if (0 <= next_x < n and 0 <= next_y < n and matrix[next_x][next_y] == 0):  
                # 判断边界
                x, y = next_x, next_y
            else:  #如果超过边界，那么就要处理
                direction_index = (direction_index + 1) % 4  # direction_index 控制方向
                x += directions[direction_index][0]
                y += directions[direction_index][1]
        return matrix

模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

由外向内一圈一圈这么画下去。

可以发现这里的边界条件非常多，在一个循环中，如此多的边界条件，如果不按照固定规则来遍历，那就是一进循环深似海，从此offer是路人。

这里一圈下来，我们要画每四条边，这四条边怎么画，每画一条边都要坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。

那么我按照左闭右开的原则，来画一圈，大家看一下：

这里每一种颜色，代表一条边，我们遍历的长度，可以看出每一个拐角处的处理规则，拐角处让给新的一条边来继续画。

这也是坚持了每条边左闭右开的原则。

一些同学做这道题目之所以一直写不好，代码越写越乱。

就是因为在画每一条边的时候，一会左开右闭，一会左闭右闭，一会又来左闭右开，岂能不乱。

代码如下，已经详细注释了每一步的目的，可以看出while循环里判断的情况是很多的，代码里处理的原则也是统一的左闭右开。

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0               # 起始点
        loop, mid = n // 2, n // 2          # 迭代次数、n为奇数时，矩阵的中心点
        count = 1                           # 计数

        for offset in range(1, loop + 1) :      # 每循环一层偏移量加1，偏移量从1开始
            for i in range(starty, n - offset) :    # 从左至右，左闭右开，offset控制的是每次填充的边界
                nums[startx][i] = count
                count += 1  # 向右填，那么对应的行不动
            for i in range(startx, n - offset) :    # 从上至下
                nums[i][n - offset] = count # 向下填，那么列不动
                count += 1
            for i in range(n - offset, starty, -1) : # 从右至左
                nums[n - offset][i] = count# 向左填，那么对应的行不动
                count += 1
            for i in range(n - offset, startx, -1) : # 从下至上
                nums[i][starty] = count# 向上填，那么列不动
                count += 1                
            startx += 1         # 更新起始点
            starty += 1
        if n % 2 != 0 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums

三、区间和

题目描述

给定一个整数数组 Array，请计算该数组在每个指定区间内元素的总和。

输入描述

第一行输入为整数数组 Array 的长度 n，接下来 n 行，每行一个整数，表示数组的元素。随后的输入为需要计算总和的区间下标：a，b （b > = a），直至文件结束。

输出描述

输出每个指定区间内元素的总和。

输入示例

输出示例

3
9

提示信息

数据范围：
0 < n <= 100000

问题分析

每个元素记录之前的和，然后利用对应的下标值相减即可

n = int(input())
li = []
for _ in range(n):
    if not li:
        li.append(int(input()))
    else:
        li.append(li[-1] + int(input()))
target = []
try:
    while 1:
        a, b = map(int, input().split())
        if a == 0:
            target.append(li[b])
        else:
            target.append(li[b] - li[a - 1])
except:
    pass
for i in target:
    print(i)

四、开发商购买土地

题目描述

在一个城市区域内，被划分成了n * m个连续的区块，每个区块都拥有不同的权值，代表着其土地价值。目前，有两家开发公司，A 公司和 B 公司，希望购买这个城市区域的土地。

现在，需要将这个城市区域的所有区块分配给 A 公司和 B 公司。

然而，由于城市规划的限制，只允许将区域按横向或纵向划分成两个子区域，而且每个子区域都必须包含一个或多个区块。为了确保公平竞争，你需要找到一种分配方式，使得 A 公司和 B 公司各自的子区域内的土地总价值之差最小。

注意：区块不可再分。

输入描述

第一行输入两个正整数，代表 n 和 m。

接下来的 n 行，每行输出 m 个正整数。

输出描述

请输出一个整数，代表两个子区域内土地总价值之间的最小差距。

输入示例

输出示例

提示信息

如果将区域按照如下方式划分：

1 2 | 3
2 1 | 3
1 2 | 3

两个子区域内土地总价值之间的最小差距可以达到 0。

数据范围：

1 <= n, m <= 100；
n 和 m 不同时为 1。

问题分析

只能横向或者说是纵向切，那么我们就要算出，横向切，之后的最小值，纵向切，之后的最小，那么就可以了

def main():
    import sys
    input = sys.stdin.read
    data = input().split()

    idx = 0
    n = int(data[idx])
    idx += 1
    m = int(data[idx])
    idx += 1
    sum = 0  # 保存总的价值
    vec = []
    for i in range(n):
        row = []
        for j in range(m):
            num = int(data[idx])
            idx += 1
            row.append(num)
            sum += num
        vec.append(row)
    # 统计横向
    horizontal = [0] * n
    for i in range(n):
        for j in range(m):
            horizontal[i] += vec[i][j]

    # 统计纵向
    vertical = [0] * m
    for j in range(m):
        for i in range(n):
            vertical[j] += vec[i][j]

    result = float('inf')
    horizontalCut = 0
    for i in range(n):
        horizontalCut += horizontal[i] # 切割
        # sum - 2 * horizontalCut 和 sum - horizontalCut - horizontalCut等价
        result = min(result, abs(sum - 2 * horizontalCut))

    verticalCut = 0
    for j in range(m):
        verticalCut += vertical[j]
        result = min(result, abs(sum - 2 * verticalCut))

    print(result)

if __name__ == "__main__":
    main()