[公开]2026年财政资金临床学生宿舍租赁项目中标公告

016/leetcode

/leetcode/1327.py
from collections import deque
from typing import List

class Solution:
def longestStrChain(self, words: List[str]) -> int:
def is_next(word, next_word):
if len(next_word) - len(word) != 1:
return False
i = 0
for j in range(len(next_word)):
if word[i] != next_word[j]:
i += 1
if i == len(word):
return True
if j == len(next_word) - 1:
return False
else:
i += 1
return True

words.sort(key = len)
dp = {}
for word in words:
dp[word] = 1
for prev_word in dp:
if is_next(prev_word, word):
dp[word] = max(dp[word], dp[prev_word] + 1)
return max(dp.values())

/leetcode/1393.py
from typing import List

class Solution:
def minimumMoves(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
# for each grid, there are 4 directions
# 0 - up
# 1 - down
# 2 - left
# 3 - right
# note the grid is 0-based index
moves = [[1, 0], [1, 1], [0, 1], [-1, 0], [-1, -1], [0, -1], [1, -1], [-1, 1]]
# the possible position of the robot
pos = {(0, 0), (m - 1, n - 1)}
# record the steps from 0, 0 to each position
steps = {(0, 0): 0}
# record the shortest steps to 0, 0
shortest_steps = float("inf")
while pos:
new_pos = set()
for x, y in pos:
for dx, dy in moves:
nx = x + dx
ny = y + dy
# the position is out of bound
if nx < 0 or nx >= m or ny < 0 or ny >= n:
continue
# the position is in the grid but is occupied
if grid[nx][ny] == 1:
continue
# the position is free
if (nx, ny) in steps:
new_steps = steps[(x, y)] + 1
if nx == m - 1 and ny == n - 1:
shortest_steps = min(shortest_steps, new_steps)
steps[(nx, ny)] = new_steps
new_pos.add((nx, ny))
pos = new_pos
return shortest_steps if shortest_steps != float("inf") else -1

/leetcode/1337.py
from typing import List

class Solution:
def findComplement(self, num: int) -> int:
num = bin(num)
num = num[2:]
num = "".join("1" if i == "0" else "0" for i in num)
return int(num, 2)

/leetcode/1369.py
from typing import List

class Solution:
def generateParenthesis(self, n: int) -> List[str]:
res = []
def backtrack(s, left, right):
if len(s) == 2 * n:
res.append(s)
return
if left < n:
backtrack(s + "(", left + 1, right)
if right < left:
backtrack(s + ")", left, right + 1)
backtrack("", 0, 0)
return res

/leetcode/1305.py
from typing import List

class Solution:
def findLucky(self, arr: List[int]) -> int:
res = -1
arr.sort()
for i in range(len(arr)):
if i == arr[i] - 1:
if arr[i] > res:
res = arr[i]
return res

/leetcode/1308.py
from typing import List

class Solution:
def findDuplicate(self, nums: List[int]) -> int:
slow = nums[0]
fast = nums[0]
while True:
slow = nums[slow]
fast = nums[nums[fast]]
if slow == fast:
break
slow = nums[0]
while slow != fast:
slow = nums[slow]
fast = nums[fast]
return slow

/leetcode/1329.py
from typing import List

class Solution:
def countVowels(self, word: str) -> int:
res = 0
for i, c in enumerate(word):
if c in "aeiou":
res += i + 1
return res

/leetcode/1386.py
from typing import List

class Solution:
def maximumSum(self, nums: List[int]) -> int:
max1, max2 = -1, -1
for n in nums:
if n > max1:
max2 = max1
max1 = n
elif n > max2:
max2 = n
return max1 + max2

/leetcode/1264.py
from typing import List

class Solution:
def generate(self, numRows: int) -> List[List[int]]:
res = [[1]]