合集-手撕算法
摘要：数组，字符串 最后一个单词长度 class Solution: def lengthOfLastWord(self, s: str) -> int: end = len(s) - 1 while s[end] == " ": end -= 1 start = end while start >= 0
阅读全文
摘要：有效的电话号码 grep -E '^(\([0-9]{3}\) [0-9]{3}-[0-9]{4}|[0-9]{3}-[0-9]{3}-[0-9]{4})$' file.txt 打印第十行 awk "NR==10" file.txt sed -n '10p' file.txt tail -n +10
阅读全文
摘要：删除重复的电子邮箱 delete from Person where id not in (select id from (select min(id) as id from Person group by email) as temp) 好友申请 II ：谁有最多的好友 select id,cou
阅读全文
摘要：懒汉式 public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) {
阅读全文
摘要：多线程循环打印ABC import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class Main { public static ReentrantLo
阅读全文
摘要：两个线程交替打印0-100 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class Main { public static Reentran
阅读全文
摘要：首先来看线程不安全的转账 public class Bank { private int[] accounts; public Bank() { this.accounts = new int[10]; for (int i = 0; i < 10; i++) { accounts[i] = 100
阅读全文
摘要：import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class CircularQueue<T> { private final T[] items; priv
阅读全文
摘要：一种不安全的写法 public class Main { public static final Object lock1 = new Object(); public static final Object lock2 = new Object(); public static void main
阅读全文
摘要：import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; pub
阅读全文
摘要：public class Main { public static void main(String[] args) throws InterruptedException, FileNotFoundException { try(FileInputStream file = new FileInp
阅读全文
摘要：import java.io.*; import java.sql.Time; import java.util.*; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; import ja
阅读全文
摘要：# Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def
阅读全文
摘要：# Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def
阅读全文
摘要：# Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def
阅读全文
摘要：# Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def removeDuplicateN
阅读全文
摘要：检测环 快慢指针法是一种用于检测链表中是否存在环的有效方法，同时也可以找到环的起点。该方法的原理基于两个指针在链表上同时移动，其中一个移动得更快，而另一个移动得更慢。 检测环的存在： 使用两个指针，一个称为快指针（fast），一个称为慢指针（slow）。 在每一步中，快指针向前移动两步，而慢指针只移
阅读全文
摘要：# Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def
阅读全文
摘要：class Node: def __init__(self, key=0, val=0, pre=None, next=None, fre=0, tail=None): self.key = key self.val = val self.pre = pre self.next = next sel
阅读全文
摘要：class Node: def __init__(self, key=0, value=0): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self,
阅读全文
摘要：Leetcode 面试题 17.14. 最小K个数 设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。 给出python实现 class Solution: def smallestK(self, arr: List[int], k: int) -> List[int]: def t
阅读全文
摘要：class Solution: def sortArray(self, nums: List[int]) -> List[int]: def quicksort(nums): if not nums: return [] pivot = random.choice(nums) less = [] e
阅读全文
摘要：class Solution: def sortArray(self, nums: List[int]) -> List[int]: def merge(nums1, nums2): if not nums1 and not nums2: return None if not nums1: retu
阅读全文
摘要：# Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def
阅读全文
摘要：class Solution: def subSort(self, array: List[int]) -> List[int]: n = len(array) start, end = -1, -1 # 从前往后找到第一个逆序 for i in range(n - 1): if array[i]
阅读全文
摘要：class Solution: def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: nums1_len = len(nums1) nums2_len = len(nums2) def find(
阅读全文
摘要：class Solution: def permute(self, nums: List[int]) -> List[List[int]]: res = [] n = len(nums) def per(nums,start): if start == n-1: res.append(nums[:]
阅读全文
摘要：class Solution: def nextPermutation(self, nums: List[int]) -> None: n = len(nums) # 找到第一个升序 t = -1 for i in range(n-2,-1,-1): if nums[i]<nums[i+1]: t
阅读全文
摘要：class Solution: def bestSeqAtIndex(self, height: List[int], weight: List[int]) -> int: n = len(height) persons = [[height[i],weight[i]] for i in range
阅读全文
摘要：class Solution: def subarraySum(self, nums: List[int], k: int) -> int: map = {0: 1} cur_sum = 0 counter = 0 for i in nums: cur_sum += i counter += map
阅读全文
摘要：num1 = input() num2 = input() def compare(num1,num2): for i in range(len(num1)): if num1[i]>num2[i]: return 0 elif num1[i]<num2[i]: return 1 return 2
阅读全文
摘要：class Solution: def addStrings(self, num1: str, num2: str) -> str: n = len(num1) m = len(num2) if n>m: for _ in range(n-m): num2 = '0'+num2 if n<m: fo
阅读全文
摘要：class Solution: def multiply(self, num1: str, num2: str) -> str: def multi(num1,num2): return (ord(num1)-ord('0')) * (ord(num2)-ord('0')) n = len(num1
阅读全文
摘要：大数相除求得商和余数 def divide_big_numbers(dividend: str, divisor: str): if divisor == "0": raise ValueError("Divisor cannot be zero.") # 判断结果符号 negative = Fal
阅读全文
摘要：给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组，是数组中的一个连续部分。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 cla
阅读全文
摘要：给定一个长度为 n 的环形整数数组 nums ，返回 nums 的非空 子数组 的最大可能和 。 环形数组 意味着数组的末端将会与开头相连呈环状。形式上， nums[i] 的下一个元素是 nums[(i + 1) % n] ， nums[i] 的前一个元素是 nums[(i - 1 + n) % n
阅读全文
摘要：class Solution: def longestPalindrome(self, s: str) -> str: n = len(s) index = 0 max_len = 1 max_str = s[0] while index < n: left = math.floor(index)
阅读全文
摘要：class Solution: def longestPalindromeSubseq(self, s: str) -> int: n = len(s) dp = [[0] * n for _ in range(n)] for i in range(n): dp[i][i] = 1 for i in
阅读全文
摘要：class Solution: def findLength(self, nums1: List[int], nums2: List[int]) -> int: n = len(nums1) m = len(nums2) dp = [[0] * (m + 1) for _ in range(n +
阅读全文
摘要：class Solution: def longestCommonSubsequence(self, text1: str, text2: str) -> int: n = len(text1) m = len(text2) dp = [[0] * (m + 1) for _ in range(n
阅读全文
摘要：class Solution: def lengthOfLIS(self, nums: List[int]) -> int: def find(nums, target): left = 0 right = len(nums) while left <= right: mid = (left + r
阅读全文
摘要：class Solution: def longestValidParentheses(self, s: str) -> int: stack = [-1] max_len = 0 for i in range(len(s)): if s[i] == "(": stack.append(i) eli
阅读全文
摘要：class Solution: def findMaxLength(self, nums: List[int]) -> int: map= {0:-1} n = len(nums) count = 0 max_len = 0 for i in range(n): if nums[i] == 0: c
阅读全文
摘要：给你一个字符串 s ，考虑其所有 重复子串 ：即 s 的（连续）子串，在 s 中出现 2 次或更多次。这些出现之间可能存在重叠。 返回 任意一个 可能具有最长长度的重复子串。如果 s 不含重复子串，那么答案为 "" 。 示例 1： 输入：s = "banana" 输出："ana" 示例 2： 输入：
阅读全文
摘要：二分法 二分法的几个位置 比如 0 1 2 3 4 5 6 7 8 9 1 2 3 3 3 3 3 4 5 6 有时候想要寻找小于3的最大数字 有时候想要寻找第一个满足>=3的数字， 有时候想要寻找最后一个满足>=3的数字， 有时候想要寻找小于4的最大数字 nums = [1, 2, 3, 4, 5
阅读全文
摘要：class Solution: def singleNonDuplicate(self, nums: List[int]) -> int: left = 0 right = len(nums)-1 res = -1 while left <= right: mid = (left+right)//2
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：public class Main { public static class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int x,TreeNode l,TreeNode r){ val = x; left = l; ri
阅读全文
摘要：class Solution: def numTrees(self, n: int) -> int: dp = [0]*(n+1) dp[0] = 1 dp[1] = 1 for i in range(2,n+1): count = 0 for left in range(0,i): count +
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：self.last = None self.res = None def dfs(root): if not root: return dfs(root.left) if self.last == pNode: self.res = root self.last = root dfs(root.ri
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：class TreeNode: def __init__(self, value=0, left=None, right=None): self.value = value self.left = left self.right = right def parent(root,p,q): if ro
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Co
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.
阅读全文
摘要：二叉树的锯齿形层序遍历 给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[20,9],[15,7]] 示例 2
阅读全文
摘要：递归写法 class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right node1 = TreeNode(1) node2 =
阅读全文
摘要：class Solution: def climbStairs(self, n: int) -> int: if n == 1 or n == 2: return n dp = [0] * (n + 1) dp[1] = 1 dp[2] = 2 for i in range(3, n + 1): d
阅读全文
摘要：class Solution: def minCostClimbingStairs(self, cost: List[int]) -> int: dp = cost n = len(dp) for i in range(2,n): dp[i] += min(dp[i-1],dp[i-2]) retu
阅读全文
摘要：class Solution: def numSquares(self, n: int) -> int: dp = [float("inf")]*(n+1) dp[0] = 0 for i in range(1,n+1): for j in range(1,int(i**(0.5))+1): dp[
阅读全文
摘要：class Solution: def coinChange(self, coins: List[int], amount: int) -> int: dp = [float("inf")] * (amount + 1) dp[0] = 0 for i in range(amount + 1): f
阅读全文
摘要：class Solution: def change(self, amount: int, coins: List[int]) -> int: dp = [0]*(amount+1) dp[0] = 1 # 从面值开始遍历是为了去重 for c in coins: for i in range(c,
阅读全文
摘要：class Solution: def numDecodings(self, s: str) -> int: if s[0] == '0': return 0 n = len(s) dp = [0] * (n + 1) dp[0] = 1 dp[1] = 1 for i in range(2, n
阅读全文
摘要：用队列实现栈 class MyStack: def __init__(self): self.length = 0 self.queue1 = [] self.queue2 = [] def push(self, x: int) -> None: self.queue1.append(x) self
阅读全文
摘要：class Solution: def trap(self, height: List[int]) -> int: n = len(height) pre = [0]*n post = [0]*n max_pre = 0 max_post = 0 for i in range(n): pre[i]
阅读全文
摘要：nums = [1,2,4,9] target = 2533 nums.sort(reverse=True) print(nums) n = len(nums) def dfs(index,num,length): print(index,num) if index == length-1: if
阅读全文
摘要：最大为 N 的数字组合 给定一个按 非递减顺序 排列的数字数组 digits 。你可以用任意次数 digits[i] 来写的数字。例如，如果 digits = ['1','3','5']，我们可以写数字，如 '13', '551', 和 '1351315'。 返回 可以生成的小于或等于给定整数 n
阅读全文
摘要：class Solution: def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]: if not nums1 or not nums2: return [] heap = [
阅读全文
摘要：class Solution: def findKthNumber(self, n: int, k: int) -> int: def findk(n,k): def countsteps(prefix,n): start = prefix end = prefix+1 steps = 0 whil
阅读全文
摘要：class Solution: def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]: n = len(nums) res = [] queue = [[0,nums[0]]] for i in range(1,k): wh
阅读全文
摘要：class Solution: def minWindow(self, s: str, t: str) -> str: def judge(map_p, map_q): for key, value in map_q.items(): if map_p.get(key, 0) < value: re
阅读全文
摘要：class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: res = [] left = 0 right = len(matrix[0]) - 1 down = len(matrix) - 1 up =
阅读全文
摘要：class Solution: def searchMatrix(self, matrix: List[List[int]], target: int) -> bool: n = len(matrix) m = len(matrix[0]) row = 0 col = m-1 while row <
阅读全文
摘要：缺失的第一个正数 给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。 请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。 class Solution: def firstMissingPositive(self, nums: List[int]) ->
阅读全文
摘要：给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。请你找到这个数组里第 k 个缺失的正整数。 示例 1： 输入：arr = [2,3,4,7,11], k = 5 输出：9 解释：缺失的正整数包括 [1,5,6,8,9,10,12,13,...] 。第 5 个缺失的正整数为 9 。 示
阅读全文
摘要：class Solution: def rand10(self): x = rand7() y = rand7() index = (x-1)*7 + y while index>40: x = rand7() y = rand7() index = (x-1)*7 + y return (inde
阅读全文
摘要：class Solution: def maxProfit(self, prices: List[int]) -> int: max_profit = 0 min_price = prices[0] n = len(prices) for i in range(n): min_price = min
阅读全文
摘要：class Solution: def maxProfit(self, prices: List[int]) -> int: n = len(prices) count = 0 for i in range(1,n): if prices[i]>prices[i-1]: count += price
阅读全文
摘要：class Solution: def maxProfit(self, prices: List[int]) -> int: n = len(prices) dp = [[[0, 0] for i in range(3)] for j in range(n)] for j in range(1, 3
阅读全文
摘要：class Solution: def maxProfit(self, k: int, prices: List[int]) -> int: n = len(prices) if k >= n // 2: res = 0 for i in range(1, n): if prices[i] > pr
阅读全文
摘要：class Node: def __init__(self,key,value,next=None): self.key = key self.value = value self.next = next class MyHashMap: def __init__(self): self.array
阅读全文
摘要：class Solution: def intersection(self, nums: List[List[int]]) -> List[int]: length = len(nums) map = {} for num in nums: for n in num: map[n] = map.ge
阅读全文
摘要：class Solution: def sumOfPowers(self, nums: List[int], k: int) -> int: n= len(nums) res = [] nums.sort() def findmin(nums): if len(nums) == 1: return
阅读全文
摘要：class Solution: def findCircleNum(self, isConnected: List[List[int]]) -> int: n = len(isConnected) visited = [0]*n count = 0 def bfs(start): queue = [
阅读全文
摘要：class Solution: def shortestPath(self, grid: List[List[int]], k: int) -> int: n = len(grid) m = len(grid[0]) if n == 1 and m == 1: return 0 visited =
阅读全文
摘要：class Solution: def fullJustify(self, words: List[str], maxWidth: int) -> List[str]: def findlen(level): count = 0 for l in level: count += len(l) ret
阅读全文
摘要：class Solution: def isBipartite(self, graph: List[List[int]]) -> bool: n = len(graph) colors = [0]*n def bfs(i): colors[i] = 1 queue = [(i,1)] while q
阅读全文
摘要：class Solution: def numBusesToDestination(self, routes: List[List[int]], source: int, target: int) -> int: if source == target: return 0 station_route
阅读全文
摘要：class Solution: def compareVersion(self, version1: str, version2: str) -> int: list1 = version1.split('.') for i in range(len(list1)): list1[i] = int(
阅读全文
摘要：给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。 你可以对数组执行 至多 k 次操作： 从数组中选择一个下标 i ，将 nums[i] 增加 或者 减少 1 。 最终数组的频率分数定义为数组中众数的 频率 。 请你返回你可以得到的 最大 频率分数。 众数指的是数组中出现次数最多的数。
阅读全文
摘要：给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 class Solution: def majorityElement(self, nums: List[int]) -
阅读全文
摘要：给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。 如果树中有不止一个众数，可以按 任意顺序 返回。 假定 BST 满足如下定义： 结点左子树中所含节点的值 小于等于 当前节点的值 结点右子树中所含节点的值 大于等于 当前节点的
阅读全文
摘要：你正在参加一个多角色游戏，每个角色都有两个主要属性：攻击 和 防御 。给你一个二维整数数组 properties ，其中 properties[i] = [attacki, defensei] 表示游戏中第 i 个角色的属性。 如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级
阅读全文
摘要：LCR 105. 岛屿的最大面积 给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。 一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。 找到给定的
阅读全文
摘要：给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1： 输入：grid = [ ["1","1","1","1","0"], ["
阅读全文
摘要：i, j = map(int, input().split()) # 解析覆盖矩阵 matrix = [] for _ in range(i): matrix.append(list(map(int, input().split()))) # 初始化目标集合（需要覆盖的所有模块） target =
阅读全文
摘要：寻找重复数(不修改原数组，只用常量级 O(1) 的额外空间) 给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。 假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。 你设计的解决方案必须 不修改 数组 n
阅读全文
浙公网安备 33010602011771号