- 博客(147)
- 收藏
- 关注
RSS订阅原创 岛屿4题集合 岛屿数量；岛屿最大面积；岛屿周长；岛屿填海求最大面积
DFS的好题岛屿数量和岛屿最大面积#1.200.岛屿数量和 2.695岛屿的最大面积 ☆☆☆class Solution: def maxAreaOfIsland(self, grid): row = len(grid) if row==0: return 0 col =len(grid[0]) res = 0 dp =[] count = 0 matri
2020-09-27 11:27:13
279
原创 剑指offer51 数组中的逆序对数量，归并排序的使用
class Solution: def reversePairs(self, nums: List[int]) -> int: if not nums: return 0 def mergesort(s,e): if s==e: #递归终止条件：只剩下1个元素时，一定是有序的 return m = s+(e-s)//2 mergeso
2020-09-07 10:48:10
153
原创 最长上升子序列，经典
class Solution: def lengthOfLIS(self, nums: List[int]) -> int: 方法一，动态规划 if not nums: return 0 dp = [1]*len(nums)#dp【0】以0位结尾的，最长上升子序列长度为1 for i in range(1,len(nums)): for j in range(i):
2020-09-06 23:02:12
164
原创 剑指offer46 把数字翻译成字符串 多种思路，必看 动态规划
动态规划-1dp【i】表示以i索引结尾时，翻译的方法数class Solution: def translateNum(self, num: int) -> int: string = str(num)#将数字转成str方便索引 dp = [0]*(len(string))###区别1 dp[0] = 1 #dp【i】的含义是第i位为止，有多少种翻译方法；dp[0]第0位为止，有1种翻译方法； #如果dp[i
2020-09-06 15:50:02
132
原创 最小方差
题意：给定一个数组，找到一个索引点i，使【0，i】和【i+1，n】的方差和最小D(x)=E(x2)-E(x)2class Solution: def find_best_cut(self,arr): n = len(arr) prex = [0] prex2 = [0] for i in arr: prex.append(prex[-1]+i) prex2.append(prex2[
2020-09-05 22:41:32
974
原创 深度学习-手写卷积和池化
手写代码实现卷积操作卷积核以滑动窗口的形式在图片滑动，每滑动一次，就计算窗口中的数据的加权之和，权值就是卷积核的数据定义卷积核k（3*3）k = np.array([ [0,1,2], [2,2,0], [0,1,2] ])r,g,b = img.split()data = np.array(r)def convolution(k,data): n,m = data.shape() img_new = []
2020-09-01 17:31:16
820
原创 215 数组中的第k个最大元素，重新学习记录快速选择
class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: def _partion(nums,left,right): rand_index = random.randint(left,right)#随机化切分元素 # randint 是包括左右区间的 nums[left],nums[rand_index] = num
2020-08-26 12:14:49
120
原创 记录记不住的知识点
记录字典的常用方法：import collectionsdic = collections.defaultdict(int)#初始化value为0的字典nums = [1,2,2,1,3,4]for num in nums: dic[num] +=1print(dic) #记录nums数组的每个数出现的次数：-> defaultdict(<class 'int'>, {1: 2, 2: 2, 3: 1, 4: 1})...
2020-08-25 21:05:59
103
原创 动态规划-最长公共子序列，最长公共子串
最长公共子序列，用动态规划的方法：返回子序列str1 = input().strip()str2 = input().strip()def LCS(str1,str2): #定义1个函数，就通过了 dp = [[0]*(len(str2)+1) for _ in range(len(str1)+1)] res = [] for i in range(1,len(str1)+1): for j in range(1,len(str2)+1):
2020-08-21 21:57:42
117
原创 牛客第2章习题
n = int(input())line =input().strip()nums = list(map(int,line.split())) #这就是这道题的知识点；python3中map后要list一下nums.sort()NN = sum(nums[::2])YY = sum(nums[1::2])print(abs(NN-YY))n , m= map(int,input().split())machines = []tasks = []for i in range(n):
2020-08-19 22:02:08
168
原创 动态规划系列1-字符串交错
对于三个字符串A，B，C。我们称C由A和B交错组成当且仅当C包含且仅包含A，B中所有字符，且对应的顺序不改变。给定三个字符串A,B和C，及他们的长度。请返回一个bool值，代表C是否由A和B交错组成即字符串交错是指由A和B组成C，且C必须包含且仅包含A和B的所有字符，且对应的顺序不改变；...
2020-08-17 16:22:18
186
原创 二分法，2球之间的最大磁力；即最大最小值问题
求最小磁力的最大值能是多大class Solution: def maxDistance(self, position: List[int], m: int) -> int: position.sort()#需要先排序，才能求最大边界值 left = min((position[i+1] - position[i]) for i in range(len(position) - 1))#最小边界值 right = position[-1]-p
2020-08-16 18:35:52
195
原创 剑指 Offer 55 - II. 平衡二叉树
输入一棵二叉树的根节点，判断该树是不是平衡二叉树；二叉树中任意节点的左右子树的深度相差不超过1，则是平衡二叉树回顾递归求深度的方案，是先求得左右子树的深度，然后进一步得到当前节点的深度，即先左右子树，再根节点；可以直接加入一个全局变量记录当前是否平衡，并额外引入一个逻辑来比较子树的深度；BFS迭代求深度的算法，是当前节点从上到下所在的层数，每个节点并不知道自己的深度（从下往上，从叶子节点到自身）class Solution: def isBalanced(self, root: TreeNo
2020-08-15 10:29:38
118
原创 剑指 Offer 54. 二叉搜索树的第k大节点 用到了莫里斯遍历
方法1：二叉搜索树的性质，中序遍历左中右是升序的；使用中序遍历的变形，右中左，则第k个数就是第k大节点class Solution: def kthLargest(self, root: TreeNode, k: int) -> int: res = [] stack =[] while stack or root: while root: stack.append(root)
2020-08-14 13:28:21
172
原创 树的遍历总结 DFS+BFS+n叉树的遍历
关于树的遍历，前序，中序，后序，各有3种方法。递归；迭代；莫里斯这里进行总结：①递归总结：递归只需注意一点，函数调用是小括号不是中括号，preorder(root)√ preorder[root]×前序class Solution: def preorderTraversal(self,root): def preorder(node): return [node.val]+preorder(node.left)+preorder(node.right) if n
2020-08-13 15:56:49
310
原创 PIL和opencv读取图片的格式转换
import cv2from PIL import Imagedir = './1.jpg'cv = cv2.imread(dir)print(type(cv)) #numpy.ndarraycv1 = cv2.cvtColor(cv,cv2.COLOR_BGR2RGB)#以前的写法是没有这一步的，直接将BGR的cv图片转成PIL，最后再转会cv BGR的格式；#其实正确的打开方式应该是先将cv图片转成RGB的格式，再生成PIL的格式pil = Image.fromarray(cv1)
2020-08-11 18:57:21
666
原创 剑指 Offer 53 - I. 在排序数组中查找数字 I 剑指 Offer 53 - II. 0～n-1中缺失的数字
剑指 Offer 53 - I. 在排序数组中查找数字 I给定排序好的上升数组，找出数组中目标值出现的次数；这种排序好的数组，找目标值在不在，出现的次数，就用二分法；示列：输入: nums = [5,7,7,8,8,10], target = 8输出: 2脑海里就推一遍[5,7,7,8,8,10], targrt=8class Solution: def search(self, nums: List[int], target: int) -> int: def
2020-08-09 13:21:33
126
原创 剑指 Offer 50. 第一个只出现一次的字符 字典加k,v的学习
class Solution:#将计数字典改为[index,cnt]这样的kv组合字典；也就是说字典的val并不一定是一个值，可以是个列表；dict[key][index]即可 def firstUniqChar(self, s: str) -> str: d = {} #字符串是可以当做列表遍历的 for i, c in enumerate(s): if c in d: #在不在字典，是看这个值是不是keys，字典.
2020-08-04 22:57:58
130
原创 剑指 Offer 49. 丑数 小根堆的用法，类似BFS
题意，丑数定义为因子只有2，3，5；1也是丑数，给定n，返回第n个丑数用小根堆，从小到大的输出丑数class Solution: def nthUglyNumber(self, n: int) -> int:#方法一 小根堆，类似BFS的思路，添加一个，考虑当前元素 v = {1} q = [1] res = 0 for i in range(n): res = heapq.heappop(q)
2020-08-04 15:59:11
103
原创 剑指 Offer 48. 最长不含重复字符的子字符串 滑动窗口思想的算法题
本题题意：给定一个字符串，找出其中最长的子字符串，且子字符串中不含重复字符；（子字符串要求连续，子序列不要求连续）滑动窗口，定义2个指针，维护窗口的起点和终点，根据当前窗口是否满足要求来进行不同的处理#滑动窗口思想;通常做法是①维护双指针代表窗口起点和终点，②然后根据当前窗口是否满足要求进行不同的处理class Solution: def lengthOfLongestSubstring(self, s: str) -> int: start = 0 #窗口的起点
2020-08-03 10:53:45
180
原创 剑指offer47礼物的最大价值
和剑指offer46一样，动态规划的题目，经典必看必学必会class Solution: def maxValue(self, grid: List[List[int]]) -> int: rows , cols = len(grid),len(grid[0]) for r in range(rows): for c in range(cols): premax=0#表示先前的最大值，初始化为0
2020-08-01 20:13:34
114
原创 剑指offer46 把数字翻译成字符串
动态规划的很经典的题目，原始方法和使用空间优化的方法，必看必学必会class Solution: def translateNum(self, num: int) -> int:#方法一 s = str(num)#整数转为字符串，才能用索引获取每个值 dp = [0]*len(s) #dp[i]表示以第i位字符为结尾的，翻译方法有多少种 dp[0]=1 for i in range(1,len(s)):
2020-08-01 19:47:19
113
原创 剑指offer45 把数组排成最小的数
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个;数字大小和字典序的大小都不行,必须满足22交换后str(a)+str(b)<str(b)+str(a)class Solution: def minNumber(self, nums: List[int]) -> str:方法一 经典快速排序的实现,实现 str(a)+str(b)<str(b)+str(a) nums = list(map(str,nums))#ma
2020-07-30 22:10:17
76
原创 剑指offer 43 1~n整数中1出现的次数
题意是给定n，输出1~n个数中，位数上有1的在每个数出现的次数和；比如n=12，则位数上有1的有1，10，11，12，一共4个，但统计的是1出现的次数，则是5次，11出现了2次1；思路是：统计一个数，其某位上出现1的总次数，然后将该数每一位上的总次数加起来就是最后的总次数规律题，当该位是0时，则出现的总次数是highdigst；当该位是0时，则出现的总次数是highdigst+low+1; 当该位是0时，则出现的总次数是(high+1)*digstwhile high != 0 or cur !
2020-07-29 14:41:05
114
原创 剑指offer42 连续子数组的最大和 经典动态规划题目
给定一个数组，求数组元素中的最大和，且要求元素是连续的；所以最大和要么是加上当前的元素，要么是从当前元素开始class Solution: def maxSubArray(self, nums: List[int]) -> int:] #动态规划的经典题目 res = float('-inf') #初始化最终结果为负无穷，因为数组可能全是负数 smax = 0 for i in nums: smax
2020-07-27 19:26:28
91
原创 剑指offer40最小的k个数 使用快速选择来写，经典；用215题数组中的第k个最大元素的方法再写一遍快速选择
class Solution: def getLeastNumbers(self, arr: List[int], k: int) -> List[int]: if k==0: return [] def partition(s,e): if s>=e: #递归出口，此时不需要额外划分 return pivot = arr[s] #定义基线点
2020-07-26 16:50:54
126
原创 剑指offer39 数组中出现次数超过一半的数字
很巧妙的算法class Solution: def majorityElement(self, nums: List[int]) -> int: res ,count = nums[0],1 #22比较，初始化res为第1个值，count=1 for i in nums[1:]: if i==res: #间接等价于字典记录每个字符的数量 count +=1 else:
2020-07-24 22:04:34
140
原创 剑指offer38 字符串的排列 字典序的排列，贪心算法
class Solution: def permutation(self, s: str) -> List[str]: res = [] def getNext(s): for i in range(len(s)-1)[::-1]: #abdc 0123 012 if s[i] < s[i+1]:#从后往前找第一个小于其后一个字符的字符i，例如dc不满足 bd满足，i=b .
2020-07-23 23:22:09
128
原创 剑指offer36 二叉搜索树与双向链表的转换 递归的应用，主要是改中序遍历打印的内容，以及对链表的学习
这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。"""# Definition for a Node.class Node: def __init__(self, val, left=None, right=None): self.val = val self.left = left self.right = right"""clas
2020-07-22 22:19:49
80
原创 剑指offer34 二叉树中和为某一值的路径 递归+迭代
# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:#方法一 .
2020-07-20 14:59:59
138
原创 剑指offer27 二叉树的镜像 递归+迭代
设计一个函数，输入一个二叉树，输出其镜像root=[4,2,7,1,3,6,9]输出[4,7,2,9,6,3,1]递归+迭代# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def mir
2020-07-19 16:58:28
112
原创 剑指offer26 树的子结构 递归学习
# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:#方法 递归 .
2020-07-19 15:36:27
81
原创 剑指offer32-Ⅰ Ⅱ Ⅲ 关于打印二叉树的题，多看几遍其实很简单
BFS的好例子，使用双端队列的数据结构解决BFS# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneimport collectionsclass Solution: def levelOrder(self, root: Tr.
2020-07-17 11:29:13
103
原创 剑指offer 剪绳子
给定长度为n的绳子，剪成m段，具体m为多少就是算法要考虑的，反正m>1，即至少要剪成2段；使剪成的每一段的长度乘积最大思考：对于n<=3，至少要剪成2段，则长度必然缩小；即长度为2，1+1=2，11=1；长度为3，1+2=3，12=3；但对于长度4就不一定，1+3，2+2都行；使用字典，记忆化搜索class Solution(object): def cuttingRope(self,n): if n<=3: return n-1 memo = {} def c
2020-06-27 12:55:45
91
原创 二叉树中的最大路径和 递归的好例子
本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。该题分为两部分，一是为每个node节点定义一个函数求贡献值，二是上一个节点的值为本身的值+左右两个节点的最大贡献值，递归回溯class Solution: def __init__(self): self.maxSum = float("-inf") def maxPathSum(self, root): def getmax(node):
2020-06-23 21:34:34
131
原创 395. 至少有K个重复字符的最长子串 t = min(set(s), key=s.count)
找到给定字符串（由小写字符组成）中的最长子串 T ， 要求 T 中的每一字符出现次数都不少于 k ，输出 T 的长度题意：给定一个字符串，找到连续的一个最长子串T ，要求T中的每一个字符的个数>=k，输出为最长子串的长度采用分治方法，中间的某个字母的个数小于k，则不是连续的，在其左右两侧继续寻找class Solution(object): def longestSubstring(self,s,k): if len(s) < k: return 0 t = min(set
2020-06-22 23:28:28
146
原创 剑指offer-数组中重复的数字
本题和287题类似，寻找重复的数字，但据博主观察，287题定义的范围是1~n，给定数组长度为n+1，即给定长度为4的数组，可取的值的范围为1，2，3，那么必然还有一个数，是重复的。该题，定义的范围是0~n-1，给定数组长度为n，即给定长度为4的数组，可取值的范围0，1，2，3，那么不一定存在重复的数字。就不能用287的方法，因为可取值0的存在。本题解法，利用范围0~n-1，即索引值，将对应的索引上放置对应的数字，如果不相等，就交换过来放置，如果相等，就放着。如果又找到一个，和要放置的索引上的值相等，那么
2020-06-17 11:31:25
92
原创 荷兰国旗问题，快速选择，partition，three way partition 快速选择的题，好题就多看几遍
1.荷兰国旗问题 【0，0，1，1，2，2，2】class Solution: def sortColors(self, nums: List[int]) -> None: ''' 荷兰三色旗问题解 ''' # 对于所有 idx < p0 : nums[idx < p0] = 0 # curr是当前考虑元素的下标 p0 = curr = 0 # 对于所有 idx &g
2020-06-15 23:05:29
177
原创 二叉搜索树的第k个最小元素，第k个最大元素
二叉搜索树的中序遍历（左中右）为升序序列，递归或迭代实现中序遍历，进而找到第k个最小的元素二叉搜索树的第k个最小元素#递归class Solution: def kthSmallest(self, root, k): def inorder(root):#中序遍历 左中右 return inorder(root.left) + [root.val] + inorder(root.right) if root else [] return
2020-06-10 23:15:08
365
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人