JonassssRo-优快云博客

原创二叉树遍历非递归

preimport typingclass Solution: def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]: if not root: return [] stack = [root] ans = [] while stack: cur = stack.pop() a

2022-03-03 14:52:42 338

原创 124. 二叉树中的最大路径和

124. 二叉树中的最大路径和import typingclass Solution: def __init__(self): self.ans = float('-inf') def maxPathSum(self, root) -> int: def helper(root): if not root: return 0 left = max(helper(root

2022-03-03 13:38:09 265

买卖股票的最佳时机1class Solution: def maxProfit(self, prices: List[int]) -> int: dp = [[-1] * 2 for _ in range(len(prices))] dp[0][0] = 0 dp[0][1] = -prices[0] for i in range(1, len(prices)): dp[i][0] = max(dp[i-

2022-03-02 16:44:32 267

原创 56. 合并区间

56. 合并区间class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]: ans = list() intervals.sort(key = lambda x : x[0]) start, end = intervals[0][0], intervals[0][1] for i in range(1,len(intervals)

2022-02-24 15:36:06 497

原创刷题记录：241. 为运算表达式设计优先级

241. 为运算表达式设计优先级class Solution: def diffWaysToCompute(self, expression: str) -> List[int]: res = list() for idx, symbol in enumerate(expression): if symbol == '+' or symbol == '-' or symbol == '*': leftP

2022-02-23 19:59:40 91

原创刷题记录：34. 在排序数组中查找元素的第一个和最后一个位置

34. 在排序数组中查找元素的第一个和最后一个位置class Solution {public: vector<int> searchRange(vector<int>& nums, int target) { if(nums.empty()) return vector<int>{-1, -1}; int left = left_bound(nums, target); if(left == -1) r

2022-02-21 11:47:03 125

原创刷题记录：19. 删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点class Solution {public: ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode *p1 = head, *p2 = head; for(int i = 0; i < n; ++i){ p1 = p1->next; } if(p1 == nullptr){

2022-02-10 23:03:33 645

原创刷题记录：10. 正则表达式匹配

10. 正则表达式匹配class Solution: def isMatch(self, s: str, p: str) -> bool: size_s, size_p = len(s), len(p) match = [[False for _ in range(size_p + 1)] for _ in range(size_s + 1)] for i in range(size_s + 1): for j in

2022-02-10 15:59:31 460

原创刷题记录：752. 打开转盘锁

752. 打开转盘锁from queue import Queueclass Solution: def openLock(self, deadends: List[str], target: str) -> int: def turnUp(s, idx): if s[idx] == '9': s = s[:idx] + '0' + s[idx+1:] else:

2022-02-07 21:32:30 426

原创刷题记录：70. 爬楼梯

70. 爬楼梯class Solution: def climbStairs(self, n: int) -> int: if n <= 2: return n pre, cur = 1, 2 for i in range(3,n+1): pre, cur = cur, pre + cur return cur

2022-02-03 19:49:16 739

原创刷题记录：5. 最长回文子串

5. 最长回文子串class Solution: def longestPalindrome(self, s: str) -> str: n = len(s) l, r = 0, 0 dp = [[False] * n for _ in range(n)] for i in range(n): dp[i][i] = True for j in range(1,n):

2022-02-03 14:44:54 480

原创刷题记录：3. 无重复字符的最长子串

3. 无重复字符的最长子串class Solution: def lengthOfLongestSubstring(self, s: str) -> int: cur_str = set() cur, longest = 0, 0 l, r, n = 0, 0, len(s) while r < n: if s[r] not in cur_str: cur_str.

2022-02-03 14:14:20 365

原创刷题记录：2. 两数相加

2. 两数相加# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: p

2022-02-03 13:41:44 470

原创刷题记录：打家劫舍123

打家劫舍1打家劫舍2打家劫舍31class Solution: def rob(self, nums): n = len(nums) if n == 1: return nums[0] pre, nxt = nums[0], max(nums[0], nums[1]) for i in range(2, n): pre, nxt = nxt, max(pre + nums[i],

2022-02-01 02:41:19 409

原创刷题记录：647. 回文子串

647. 回文子串class Solution: def countSubstrings(self, s: str) -> int: n = len(s) dp = [[False] * n for _ in range(n)] count = n for i in range(n): dp[i][i] = True for j in range(1,n):

2022-02-01 02:04:08 454

原创刷题记录：1143. 最长公共子序列

1143. 最长公共子序列常规动态规划class Solution: def longestCommonSubsequence(self, text1: str, text2: str) -> int: n1, n2 = len(text1), len(text2) dp = [[0] * (n2 + 1) for _ in range(n1 + 1)] for i in range(1, n1 + 1): for

2022-01-30 23:28:23 713

原创刷题记录：416. 分割等和子集

416. 分割等和子集class Solution: def canPartition(self, nums: List[int]) -> bool: target = sum(nums) / 2 if target != int(target): return False n = len(nums) target = int(target) dp = [[False]

2022-01-30 21:28:24 568

原创刷题记录：322. 零钱兑换12

322. 零钱兑换很常规的动规class Solution: def coinChange(self, coins: List[int], amount: int) -> int: dp = [float('inf') for _ in range(amount + 1)] dp[0] = 0 # print(dp) for i in range(1,amount+1): for coin in coi

2022-01-30 12:15:12 382

原创刷题记录：538. 把二叉搜索树转换为累加树

538. 把二叉搜索树转换为累加树# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = rightclass Solution: def convertBST(self, root:

2022-01-27 16:53:34 302

原创刷题记录：347. 前 K 个高频元素

347. 前 K 个高频元素1 暴力计数+排序 O(nlogn)class Solution: def topKFrequent(self, nums: List[int], k: int) -> List[int]: count = collections.defaultdict(int) for val in nums: count[val] += 1 return sorted(coun

2022-01-23 16:46:01 358

原创刷题记录：437. 路径总和 III

437. 路径总和 III方法1 爆搜竟然不超时！~class Solution: def pathSum(self, root: TreeNode, targetSum: int) -> int: count = 0 def dfs(root, cur_sum): if not root: return if cur_sum + root.val == targetSum:

2022-01-22 21:58:33 1576

原创刷题记录：312. 戳气球

312. 戳气球class Solution: def maxCoins(self, nums: List[int]) -> int: nums_extra = [1] + nums + [1] size = len(nums_extra) dp = [[0] * size for _ in range(size)] for len_of_sec in range(2, size): # enumerate differen

2022-01-22 20:25:03 272

原创刷题记录：560. 和为 K 的子数组

560. 和为 K 的子数组class Solution: def subarraySum(self, nums: List[int], k: int) -> int: HashMap = {0:1} n = len(nums) count, pre = 0, 0 for i in range(n): pre += nums[i] if pre - k in HashMap:

2022-01-20 21:41:10 670

原创刷题记录：543. 二叉树的直径

543. 二叉树的直径# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = rightclass Solution: def diameterOfBinaryTree(self, r

2022-01-20 19:43:06 197

原创刷题记录：删除无效的括号

删除无效的括号考虑到题目要求求出所有最长组合，考虑用暴力搜索尝试每一种情况，并在特定情况进行剪枝。import copyclass Solution: def removeInvalidParentheses(self, s): l_count, l_remove = 0, 0 r_count, r_remove = 0, 0 for i in s: if i == '(': l_count

2022-01-19 12:50:30 548

原创刷题记录：反转二叉树

反转二叉树class Solution: def invertTree(self, root): def swap(node): if node == None: return node.right, node.left = node.left, node.right swap(node.left) swap(node.right) swa

2022-01-14 20:56:58 106

原创刷题记录：207. 课程表

207. 课程表考查是否有环class Solution: def canFinish(self, numCourses, prerequisites): HashMap = {} for prerequisite in prerequisites: start, end = prerequisite[1], prerequisite[0] if start not in HashMap:

2022-01-14 20:06:03 101

原创刷题记录：最大正方形

最大正方形class Solution: def maximalSquare(self, matrix): m, n = len(matrix), len(matrix[0]) # define the DP array dp = [[0] * n for _ in range(m)] # start DP maxArea = float("-inf") for i in range(m):

2022-01-07 20:58:37 103

原创刷题记录：岛屿数量

岛屿数量class Solution: def numIslands(self, grid): m, n = len(grid), len(grid[0]) isUsed = [[False] * n for _ in range(m)] # print(isUsed) directions = [[1, 0], [-1, 0], [0, -1], [0, 1]] Islands = 0 def df

2022-01-07 20:57:11 350

原创刷题记录：每日温度

每日温度class Solution: def dailyTemperatures(self, temperatures: List[int]) -> List[int]: stack = [] # to store the index res = [0] * len(temperatures) for day,temperature in enumerate(temperatures): while stack an

2022-01-07 13:24:28 110

原创刷题记录：LRU

LRU# jonas 2022.1.6class Doublelist: def __init__(self, key=None, val=None, pre=None, _next=None): # key value pair self.key = key self.val = val # pointer to the pre,next node self.pre = pre self.next

2022-01-06 15:36:18 90

原创刷题记录：二叉树展开为链表

二叉树展开为链表# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = rightclass Solution: def flatten(self, root: TreeNode) -

2022-01-05 20:06:34 595

原创刷题记录：单词搜索

单词搜索class Solution: def exist(self, board, word): directions = [[-1, 0], [1, 0], [0, -1], [0, 1]] row, col = len(board), len(board[0]) matrix = [[True] * col for _ in range(row)] ans = False def backtracking(id

2022-01-05 16:56:18 200

原创刷题记录：颜色分类

颜色分类class Solution: def sortColors(self, nums: List[int]) -> None: """ Do not return anything, modify nums in-place instead. """ p0,p1 = 0,0 for index in range(len(nums)): if nums[index] == 0

2022-01-05 13:38:59 626

原创刷题记录：最小路径和

最小路径和class Solution: def minPathSum(self, grid: List[List[int]]) -> int: dp = copy.deepcopy(grid) for i in range(1,len(grid)): dp[i][0] += dp[i-1][0] for j in range(1,len(grid[0])): dp[0][j] += dp[0][

2022-01-05 11:51:25 157

原创刷题记录：最大子数组和

最大子数组和class Solution: def maxSubArray(self, nums: List[int]) -> int: if len(nums) == 1: return nums[0] dp = copy.deepcopy(nums) // travese from end to begin ans = nums[-1] for i in range(len(nums)

2022-01-04 15:30:28 259

原创刷题记录：全排列

全排列class Solution: def permute(self, nums: List[int]) -> List[List[int]]: ans = [] cur_comb = [] size_nums = len(nums) // base case if len(nums) == 1: return [nums] elif not nums:

2022-01-04 14:49:39 270

原创刷题记录：组合总和

组合总和class Solution: def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: ans = [] combination = [] cur_total = 0 candidates.sort() // print(candidates) def backtracking(idx

2022-01-04 14:27:34 186

原创刷题记录：搜索旋转排序数组

搜索旋转排序数组class Solution: def search(self, nums: List[int], target: int) -> int: p_left,p_right = 0,len(nums)-1 while p_left <= p_right: mid = (p_right - p_left)//2 + p_left if nums[mid] == target:

2022-01-03 19:48:41 172

原创刷题记录：最长有效括号

最长有效括号class Solution: def longestValidParentheses(self, s: str) -> int: if not s: return 0 res = 0 stack = [-1] # travesal the list for i in range(len(s)): if s[i] == "(":

2021-12-30 15:00:48 214

空空如也

空空如也