代码随想录 day2

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

进阶：
请你设计时间复杂度为 O(n) 的算法解决本问题

双指针法
数组其实是有序的， 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
此时可以考虑双指针法了，i指向起始位置，j指向终止位置。
定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。
如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。
如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

做题的时候自己能分析出来时间复杂度就可以了，至于leetcode上执行用时，大概看一下就行，
只要达到最优的时间复杂度就可以了，

暴力实现

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()
        return nums

双指针 + 新数组

写法1

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        lens = len(nums)
        nums1 = [0] * lens

        left, right =0,  lens - 1
        nums = [nums[i] ** 2 for i in range(lens)]
        for i in range(lens-1, -1, -1):
            if nums[left] > nums[right]:
                nums1[i] = nums[left]
                left += 1
            else:
                nums1[i] = nums[right]
                right -= 1
        return nums1

写法2

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        lens = len(nums)
        nums1 = [0] * lens
        i = lens - 1
        left, right =0,  lens - 1
        nums = [nums[i] ** 2 for i in range(lens)]
        while left <= right:
            if nums[left] > nums[right]:
                nums1[i] = nums[left]
                left += 1
            else:
                nums1[i] = nums[right]
                right -= 1
            i -= 1
        return nums1

209. 长度最小的子数组

给定一个含有 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 <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

滑动窗口

不断的调整子序列的起点和终点的位置， 从而得到我们想要的结果。

对应2个for循环方法：
第一个for，确定了滑动窗口起点的位置， 第二个for确定了滑动窗口终点的位置。
用两个for循环完成了一个不断搜索区间的过程。

滑动窗口小记：
1. 窗口内是什么？
2. 如何移动窗口的起始位置?
3. 如何移动窗口的结束位置?

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于等于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

写法1, 滑动指针

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        min_len = 1e5 + 100
        lens = len(nums)
        if len(nums) == 0: min_len = 0
        left = 0
        right = 0
        sum = nums[0]
        while (left <= right) & (right < lens):
            if sum < target:
                if (right + 1 < lens):
                    right += 1
                    sum += nums[right]
                else:
                    min_len = 0 if min_len == 1e5 + 100 else min_len
                    return min_len   # 最后一次比较
            else:
                ### sum >= target, left所有右移动
                temp_ = right - left + 1
                print(left, right, temp_, sum, 'tt--')
                sum -= nums[left]
                left += 1
                while (sum >= target) & (left < right):   ### 找到当前区间最小的sum >= target
                    temp_ = min(right - left + 1, temp_)
                    print(left, right, temp_, sum, 'tt')
                    sum -= nums[left]
                    left += 1
                min_len = temp_ if temp_ < min_len else min_len

        min_len = 0 if min_len == 1e5 + 100 else min_len
        return min_len

写法2

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        min_len = 1e5 + 100
        lens = len(nums)
        left = 0
        right = 0
        sum = 0
        while (right < lens):
            sum += nums[right]
            while (sum >= target):
                min_len = min(min_len, right - left + 1)
                sum -= nums[left]
                left += 1   #因为的每一个值都为正整数， 所以最小的min sum = 0。
            right += 1
        if min_len == 1e5 + 100:
            return 0
        return min_len

这个题还没有开始做， 留到以后有时间做。