思路：每次取最中间的数，比较大小，然后确定在左侧还是在右侧。区间取左闭右开
用时3：15，注意判断完nums【mid】的大小后，如果left需要调整，因为左闭右开，mid出已经判断过了，所以跳过mid，left=mid+1；如果right出需要调整，直接等于mid，因为右侧开
python
class Solution:
def search(self, nums: List[int], target: int) -> int:
left, right = 0, len(nums)
while left<right:
mid = (left+right)//2
if target > nums[mid]:
left = mid+1
elif target < nums[mid]:
right = mid
else:
return mid
return -1
思路：移除值为val的数，也即碰到不为val的数，保存在原地。如果碰到val，慢指针停1步，快指针正常向前，并让res += 1
用时5：57.除了小问题在最后返回res的时候，应该返回nums 中与 val 不同的元素的数量。是len(nums)-res。
python
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
slow,fast = 0,0
res = 0
while fast < len(nums):
if nums[fast] != val:
nums[slow] = nums[fast]
slow += 1
fast += 1
else:
fast += 1
res += 1
return len(nums)-res
思路：从两头开始排序，考虑左侧和右侧平方谁大，交替放到新数组里，成为一个非递增数组，然后对其排序，复杂度O(nlogn)，能通过
python
class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
n = len(nums)
ans = [0] * n
i, j = 0, n - 1
for p in range(n - 1, -1, -1):
x = nums[i] * nums[i]
y = nums[j] * nums[j]
if x > y:
ans[p] = x
i += 1
else:
ans[p] = y
j -= 1
return ans
改进思路：建好长为n的数组，从后往前放，节省了排序的复杂度
python
class Solution:
def sortedSquares(self, nums: List[int]) -> List[int]:
slow,fast = 0, len(nums)-1
res = [0]*len(nums)
idx = len(nums)-1
while slow<=fast:
if nums[slow]**2 <= nums[fast]**2:
res[idx] = (nums[fast]**2)
fast -= 1
idx -= 1
else:
res[idx] = (nums[slow]**2)
slow += 1
idx -= 1
return res
思路：维护一个滑动窗口，记住当前窗口里的综合和长度，如果总和不够窗口长度+=1，超过-=1，记录最大窗口长度
错误出在right的初始化上，考虑初始情况下，应该长度为0，总和为0，这样比较合理。做的时候初始化左右为0，1.把第一个数放进sum，这样在只有一个数时发生错误
python
class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
if not nums:
return 0
left, right = 0, 0
sum_win = 0
res = inf
while right < len(nums):
while sum_win < target and right < len(nums):
sum_win += nums[right]
right += 1
while sum_win >= target:
res = min(res, right-left)
sum_win -= nums[left]
left += 1
return res if res != inf else 0
思路：考虑把所有数用完的条件下，到达边界即遍历停止。
具体来说，上下左右四个边界定义好，我这里考虑的边界在矩阵外，所以在循环中要注意range的位置，举例说明：
首先处理第一行，遍历每一个格子放好数字（这里记得数字还得从1开始），直到最后一个数，这样第一行放满了，up+=1；然后处理right-1列，right-=1；然后处理最后一行，从right-1列到left-1列；最后处理第一列，如此循环
python
class Solution:
def generateMatrix(self, n: int) -> List[List[int]]:
up,down,left,right = 0,n,0,n
i = 1
res = [[0]*n for _ in range(n)]
while i <= n**2:
for a in range(left,right):
res[up][a] = i
i+=1
up +=1
for b in range(up,down):
res[b][right-1] = i
i += 1
right -= 1
for c in range(right-1,left-1,-1):
res[down-1][c] = i
i+= 1
down -= 1
for d in range(down-1, up-1, -1):
res[d][left] = i
i+=1
left += 1
return res- 开发商购买土地
思路：考虑二维前缀和，分别获取每一列和每一行的加和，计算前缀和。用矩阵总和-2*前缀和，再取绝对值及得到了此时的价值之差，去最小的即可
简单讲一下这里的数据获取部分
python
import sys
data = sys.stdin.read().split()
idx = 0
n = int(data[idx])
idx+=1
m = int(data[idx])
idx+=1
arr = [[0]*m for _ in range(n)]
for i in range(n):
for j in range(m):
arr[i][j] = int(data[idx])
idx+=1使用sys.stdin.read().split()处理，获得数据的散列表，在进行处理，也可以用readline方法，依次读取每一行的数据，注意获取的都是str，需要显示转化为int和list
python
import sys
n,m = map(int,sys.stdin.readline().split())
arr = []
for i in range(n):
row = list(map(int,sys.stdin.readline().split()))
arr.append(row)后续内容相对比较简明易懂
python
arr1 = [0]*(m+1)
arr2 = [0]*(n+1)
min_value = float('inf')
#算每一列
for j in range(m):
sum1 = 0
for i in range(n):
sum1 += arr[i][j]
arr1[j+1] = sum1 + arr1[j]
print(arr1)
#算每一行
for i in range(n):
sum2 = 0
for j in range(m):
sum2 += arr[i][j]
arr2[i+1] = sum2 + arr2[i]
#横向划分
for i in range(1,n):
if abs(arr2[n] - 2*arr2[i])<min_value:
min_value = abs(arr2[n] - 2*arr2[i])
#纵向划分
for j in range(1,m):
if abs(arr1[m] - 2*arr1[j])<min_value:
min_value = abs(arr1[m] - 2*arr1[j])
print(min_value)