LeeCode数组问题（二）

LeeCode 977：有序数组的平方

题目描述：

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

标签：数组，首尾指针，最大值优先

时间复杂度：O(N)

建立模型：

1. 定义首、尾指针(首指针指向nums[0]，尾指针指向nums[len(nums) - 1])
2. 比较首尾指针元素的绝对值(绝对值的大小和平方是一致的)
3. 若首指针元素的绝对值大于等于尾指针元素，则将首指针元素的平方添加到结果res的尾部，然后首指针右移
4. 若首指针元素的绝对值小于尾指针元素，则将尾指针元素的平方添加到结果res的尾部，然后尾指针左移
5. 重复步骤2、3、4，直至所有元素添加完毕

代码实现：

# Python3 实现
def sorted_squares(nums: List[int]) -> List[int]:
    res = [0 for _ in range(len(nums))]
    i, j = 0, len(nums) - 1
    cur = len(nums) - 1    #表示当前插入res的位置
    
    while i <= j:
        if abs(nums[i]) >= abs(nums[j]):
            res[cur] = pow(nums[i], 2)
            i += 1
        else:
            res[cur] = pow(nums[j], 2)
            j -= 1
        cur -= 1
    
    return res

// Java 实现
public int[] sorted_squares(int[] nums) {
  int[] res = new int[nums.length];
  int i = 0, j = nums.length - 1;
  int cur = nums.length - 1;
    
  while (i <= j) {
    if (Math.abs(nums[i]) >= Math.abs(nums[j])) {
      res[cur] = nums[i] * nums[i];
      i += 1;
    }
    else {
      res[cur] = nums[j] * nums[j];
      j -= 1;
    }
    
    cur -= 1;
  }
  
  return res;
}

LeeCode 209：长度最小的子数组

题目描述：

给定一个含n个正整数的数组和一个正整数target。找出该数组中满足其和\(\ge target\)的长度最小的**连续子数组，并返回其长度。若不存在符合条件的子数组，则返回0。

标签：数组，滑动窗口，前缀和

时间复杂度：O(N)

建立模型：

1. 定义窗口的起始位置和窗口的结束位置
2. 计算窗口内元素的和sum
3. 如果 \(sum \ge target\)，则比较窗口和res的大小，取其中较小的值，并将窗口起始位置右移
4. 如果 \(sum < target\)，则将窗口结束位置右移
5. 重复步骤2、3、4，直至窗口结束位置到达数组尾部

代码实现：

# Python3 实现
def min_sub_array_len(target: int, nums: List[int]) -> int:
    res = len(nums) + 1
    i, s = 0, 0    # i: 滑动窗口起始位置, s: 滑动窗口内元素和
    for j in range(len(nums)):    # j: 滑动窗口结束位置
        s += nums[j]
        while s >= target:
            res = min(res, j - i + 1)
            s -= nums[i]
            i += 1
    
    return res if res < len(nums) + 1 else 0

// Java 实现
public int min_sub_array_len(int target, int[] nums) {
  int res = Integer.MAX_VALUE;
  int i = 0, sum = 0;
  for(int j = 0; j < nums.length; j++) {
    sum += nums[j];
    while (sum >= target) {
      res = Math.min(res, j - i + 1);
      sum -= nums[i];
      i += 1;
    }
  }
  
  return res == Integer.MAX_VALUE ? 0 : res;
}

LeeCode 59：螺旋矩阵

题目描述：

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

标签：数组，矩阵，模拟

时间复杂度：\(O(N^2)\)

建立模型：

1. 定义填充矩阵时的4个移动方向，并按顺序排列(即\(右移 \rightarrow下移 \rightarrow 左移 \rightarrow 上移\))
2. 填充当前位置，并计算下一个填充位置，判断其是否为有效位置
3. 若位置有效，则下一个填充位置即是此位置
4. 若位置无效，则需要改变移动方向，重新计算下一个填充位置(改变方向之后的第一个填充位置一定是有效位置，所以无需判断该位置是否有效)
5. 重复2、3、4，直至所有位置填充完毕

代码实现：

# Python3 实现
def generate_matrix(n: int) -> List[List[int]]:
    # (0, 1): 水平右移; (1, 0): 垂直下移; (0, -1): 水平左移; (-1, 0): 垂直上移
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    index = 0
    row, col = 0, 0
    
    res = [[0 for _ in range(n)] for _ in range(n)]
    for num in range(1, pow(n, 2) + 1):
        res[row][col] = num
        (dx, dy) = directions[index]
        new_row, new_col = row + dx, col + dy    # 计算下一个填充的位置
        
        # 判断下一个填充的位置是否有效
        # res[new_row][new_col] > 0 表示该位置已填充过
        if new_row < 0 or new_row >= n or new_col < 0 or new_col >= n or res[new_row][new_col] > 0:
            index = (index + 1) % 4
            (dx, dy) = directions[index]
            row, col = row + dx, col + dy
    
    return res

// Java 实现
public int[][] generate_matrix(int n) {
  int[][] res = new int[n][n];
  int[][] directions = {{0, 1}, {1, 0}, {0， -1}, {-1, 0}};
  
  int index = 0;
  int row = 0, col = 0;
  for (int num = 1; num <= n * n; num++) {
    res[row][col] = num;
    int new_row = row + directions[index][0];
    int new_col = col + directions[index][1];
    if(new_row < 0 || new_row >= n || new_col < 0 || new_col >= n || res[new_row][new_col] > 0) {
      index = (index + 1) % 4;
    }
    
    row = row + directions[index][0];
    col = col + directions[index][1];
  }
  
  return res;
}