day2 209.长度最小的子数组 59.螺旋矩阵|| 区间和 开发商购买土地

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

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

提示：

• 1 <= target <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

第一种写法（滑动窗口）：

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        l = len(nums)
        left = 0
        right = 0
        min_len = float('inf')
        cur_sum = 0

        while right < l: # 循环索引是终止位置
            cur_sum += nums[right] # 窗口里的元素和

            while cur_sum >= target: # 只要窗口元素和满足要求，获取数组长度
                min_len = min(min_len, right - left + 1) # 不断获得最小数组长度
                cur_sum -= nums[left] # 减去起始位置元素
                left += 1 # 向后移动起始位置索引

            right += 1 # 向后移动终止位置

        return min_len if min_len !=float('inf') else 0

59.螺旋矩阵

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

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

#

第一种写法：

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

        for offset in range(1, loop + 1):
            for i in range(starty, n - 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:
            nums[mid][mid] = count

        return nums

区间和

题目描述

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

输入描述

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

输出描述

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

输入示例

5
1
2
3
4
5
0 1
1 3

1
2
3
4
5
6
7
8

输出示例

3
9

1
2

数据范围：

0 < n <= 100000

第一种写法：

import sys
input = sys.stdin.read

def main():
    data = input().split()
    index = 0
    n = int(data[index])
    index += 1
    vec = []
    for i in range(n):
        vec.append(int(data[index + i]))
    index += n 
    
    p = [0] * n 
    presum = 0
    for i in range(n):
        presum += vec[i]
        p[i] = presum
        
    results = []
    while index < len(data) - 1:
        a = int(data[index])
        b = int(data[index + 1])
        index += 2
        
        if a == 0:
            sum_value = p[b]
        else:
            sum_value = p[b] - p[a - 1]
            
        results.append(sum_value)
        
    for result in results:
        print(result)
        
if __name__ == "__main__":
    main()

开发商购买土地

【题目描述】

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

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

然而，由于城市规划的限制，只允许将区域按横向或纵向划分成两个子区域，而且每个子区域都必须包含一个或多个区块。

为了确保公平竞争，你需要找到一种分配方式，使得 A 公司和 B 公司各自的子区域内的土地总价值之差最小。

注意：区块不可再分。

【输入描述】

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

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

输出描述

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

【输入示例】

3 3 1 2 3 2 1 3 1 2 3

【输出示例】

0

【提示信息】

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

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]
        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()