代码随想录算法训练营第二天|LC209.长度最小的子数组|LC59.螺旋矩阵Ⅱ|区间和|开发商购买土地

LC209.长度最小的子数组

        1、正整数数组

        2、长度最小的子数组（和大于或等于target）

思路：使用双指针法：根据指针的滑动来滑动计算指针范围内的值与target进行比较；

滑动窗口法：（自我理解版本）使用2个指针（类似快慢指针），当一个指针一直移动，计算2个指针之间的值是否和目标值相等，若小于目标值，则指针一直向右移动，若大于目标值，则另一个指针向右移动；

# 滑动窗口法
from typing import List


class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        if sum(nums) < target:
            return 0
        start = 0
        end = 0
        # 用来计算窗口值，与目标值进行比较
        cur_sum = 0
        # 初始化一个无穷大，与获取的值的进行比较，已得到最小值
        min_len = float('inf')
        while end < len(nums):
            cur_sum = cur_sum + nums[end]
            while cur_sum >= target:
                # +1 是因为输出的是个数，目前计算的都是索引，需要+1
                min_len = min(min_len, end-start+1)
                cur_sum = cur_sum - nums[start]
                start += 1
            end += 1
        return min_len


if __name__ == '__main__':
    target = 7
    nums = [2, 3, 1, 2, 4, 3]
    res = Solution().minSubArrayLen(target, nums)
    print(res)

LC59.螺旋矩阵Ⅱ

        1、1-n^2所有元素

        2、顺时针螺旋排列

难点：特别使对于上述旋转的边界控制，需要控制一致，都左闭右开进行统一；（该题有困难，还未完全理解，等待第二遍刷继续熟悉；）

from typing import List


class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0]*n for _ in range(n)]
        startx, starty = 0, 0
        loop = n//2
        mid = n//2
        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


if __name__ == '__main__':
    n = 3
    res = Solution().generateMatrix(n)
    print(res)

卡码网58.区间和

前缀和：在设计计算区间和的问题非常有用

前缀和思想：利用重复计算过的数组之和，从而降低区间查询需要累加计算的次数。（有点像递归，使用前面计算过的值）

def main():
    # 输入数组长度
    n = int(input())
    # 初始化前缀和数组 
    prefix_sum = [0] * n
    # 初始化前缀和变量，一直累加
    s = 0
    # 长度为n的数组累加
    for i in range(n):
        # 输入单个数组变量
        value = int(input())
        # 累加到前缀和
        s += value
        # 保存在前缀和数组中，输入：1 2 3 4 5 => 1 3 6 10 15
        prefix_sum[i] = s
    while True:
        try:
            # 输入两个区间值
            nums = input().split()
        except:
            break
        # 区间相减
        # 当区间第一个值为0时，即输出区间第二个值
        if int(nums[0]) == 0:
            print(prefix_sum[int(nums[1])])
        else:
            # 例如[1,3]，最后的输出是[3，0]的值才符合要求，具体写个草稿就明白；
            print(prefix_sum[int(nums[1])] - prefix_sum[int(nums[0])-1])


if __name__ == '__main__':
    main()

    # 0 1 3 6 10 15

注意：区间【1，3】（指1，2，3的值累加，以数学中的区间进行理解，2边都包括）的值是由区间【0，3】（指0，1，2，3的值累加减曲0的值）的两者相减得到。

卡码网44. 开发商购买土地

该题没有理解什么意思，做个标记， 下次在来看：

 原因：1、没有理解idx的意义，一直+1；（idx具体作用）

            2、在pycharm中运行的时候，对输入case的不理解，一直出现超出数据维度的情况；

            3、没有理解这种方式如何对case数据进行输入的模式；

最后附上通过的代码：

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])  # 运行到这里就报错了，不知道是case输入的不对还是别的原因，总是超出数据维度，没有理解具体意思；
            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()