07 2022 档案
摘要：66. 加一 -< map(function, iterable, ...) 现对map函数就行如下的解释： map()返回一个与传入可迭代对象大小一样的map对象 经常与Python中的lambda函数搭配 test = map(lambda n :n*n,range(1,11)) print(l
阅读全文
摘要：67. 二进制求和 -< bin() 返回一个整数 int 或者长整数 long int 的二进制表示 ->: class Solution: def addBinary(self, a: str, b: str) -> str: return bin(int(a,2)+int(b,2))[2:]#
阅读全文
摘要：63. 不同路径 II -> 就前一题而言，在其基础上添加判断条件，当遇到障碍时，置为0并在边界条件下也需要做判断，话不多说 -<： class Solution: def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -
阅读全文
摘要：64. 最小路径和 -< 动态规划,dp[i][j]=dp[i-1][j]+dp[i][j-1],但是其中边界等于grid[i][0]和grid[0][j] 代码： class Solution: def minPathSum(self, grid: List[List[int]]) -> int:
阅读全文
摘要：65. 有效数字 个人感觉这种题目没太有意思 class Solution: def isNumber(self, s: str) -> bool: if s in ["inf", "-inf", "+inf", "Infinity", "+Infinity", "-Infinity"]: retu
阅读全文
摘要：62.不同路径 -< 往下n次往右m次，从起点开始需移动n-1和m-1次 因此在n+m-2中选取n-1次，其余向右走 demo1: class Solution: def uniquePaths(self, m: int, n: int) -> int: return comb(n+m-2,n-1)
阅读全文
摘要：60. 排列序列 -> 方式一：找规律 eg：n=3,k=3 '123' '132' '213' '231' '312' '321' 每个首位1 2种 即找到3/2即可 -< 代码： class Solution: def getPermutation(self, n: int, k: int) -
阅读全文
摘要：61. 旋转链表 ->每个节点都要移动，因此想到连接到一起 1.找尾节点，形成环形链表 2.尾节点移动length-k步(又移k步==左移length-k步) 3.找到头节点，断开头尾连接 -<代码： # Definition for singly-linked list. # class List
阅读全文
摘要：59. 螺旋矩阵 II ->依据题意,和54题相似,填充方向按照上右下左(边界)即从左到右.从上到下... 找出填充的边界,设置left=0,right=n-1,up=0,down=n-1然后开始向内螺旋 -<开始模拟: class Solution: def generateMatrix(self
阅读全文
摘要：58. 最后一个单词的长度 ->本题较为简单，但仔细一想，strip().split()俩者分不特别清楚，因此现做如下说明 strip()：删除 --Ⅰ split()：分割 -- Ⅱ Ⅰ:默认删除空白符,若添加rm,则删除头尾rm Ⅱ:需要添加分割条件,添加以此为分割,可分割多次 代码: clas
阅读全文
摘要：56. 合并区间 ->用sort()函数排序：按a[0],a[1]大小排序 判断区间重叠：eg- a=[1,4] b=[2,3] a[1]>b[0] 左边位置为a[0],右边位置为max(a[1],b[1]) 所以区间是[1,4] -<代码： class Solution: def merge(se
阅读全文
摘要：->最初想法：一直跳能调到的最大值 使用方法：动态规划 初值：max_len==nums[0]表达式：ax_len = max(max_len,i+nums[i])条件：max_len>=i返回：max_len>=len(nums)-1 return Trueelse return False cl
阅读全文
摘要：整体思路 ->对于螺旋矩阵的题目四点： 1.起始位置 2.移动边界 3.边界 4.结束条件-<介于本题分别是： 1.左上角(0，0) 2.→↓←↑，使用二维数组存储 3.当每行遍历结束后，需要向内部移动从而达到螺旋 4.所有位置被遍历到 class Solution: def spiralOrder
阅读全文
摘要：如果用暴力法求解,其时间复杂度会达到n^2但可以进行优化,设置列表存放每个其最大和,然后直接返回最大值判断最大和:前一位列表和加入nums[i] 和 现在值进行比较,大者返回,否则是从现在开始,并加入其中列表其时间复杂度为O(n) class Solution: def maxSubArray(se
阅读全文
摘要：整体思路：解决三个问题行列以及斜线简言之每行只有一个且不重复位置的条件下满足无斜线利用一个queen数组来进行移动，diagnose_对角线分别满足行列之和和之差相等如果满足则前进不满足就回溯 class Solution: def solveNQueens(self, n: int) -> Lis
阅读全文
摘要：#<<(向左位移) 针对二进制，转换成二进制后(32位)向左边移动n位 ，相当于这个整数乘以2的n次方； #>>(向右位移) 针对二进制，转换成二进制后(32位)向右移动n位,相当于这个整数除以2的n次方,正数高位补0, 正数高位补1 class Solution(object): def myPo
阅读全文
摘要：#首先进行排序把相同字符的排到一起#遍历把排序字符当键，原元素当值加入列表 class Solution: def groupAnagrams(self, strs: List[str]) -> List[List[str]]: if len(strs)<=1: return [strs] r =
阅读全文
摘要：①沿对角线进行翻折 ②每行就行反转 本质：除开对角线进行180°翻折，在每一行进行反转返回90°就可以达到反转90°的效果 class Solution: def rotate(self, matrix: List[List[int]]) -> None: """ Do not return any
阅读全文
摘要：NO46. 全排列#考察回溯,[1,2,3,4]->1+[2,3,4]->1+2+[3,4] # ->1+3+[2,4]... # 之后重置往前返回 #也类似深度优先遍历,把每层的最深一层找到然后返回,再重复操作 class Solution: def permute(self, nums: Lis
阅读全文
摘要：#和之前通配符匹配很像，dp的思路 class Solution: def isMatch(self, s: str, p: str) -> bool: vertical = len(p)+1 #纵向的长度，由于有初始start因此加一 level = len(s)+1 if set(p) == {
阅读全文
摘要：#最近的算法都是考查思维而不是特定算法，值得一试 #按层 class Solution: def trap(self, height: List[int]) -> int: n=len(height) left,right=0,n-1 tmp,high=0,1 while(left<=right):
阅读全文
摘要：#偷巧法 #正整数是指大于0的数，那想到添加参数0，然后进行比较 #如果是连续的就返回最后一个值，否则返回跳跃的那个值 class Solution: def firstMissingPositive(self, nums: List[int]) -> int: nums.append(0) num
阅读全文
摘要：#导入相关的库 import tensorflow as tf import os import numpy as np import matplotlib.pyplot as plt <!-- 打标签 设定猫为0，狗为1 打乱数据集，细节如下 --> #读取数据集中所有图片的路径和标签 def g
阅读全文
摘要：import tensorflow.compat.v1 as tf tf.disable_v2_behavior() import numpy as np from matplotlib import pyplot as plt #添加层 def add_layer(inputs, in_size,
阅读全文
摘要：激励函数运行时激活神经网络中某一部分神经元，将激活信息向后传入下一层的神经系统 含有如下激励函数: tf.nn.sigmoid：将实数压缩到0到1之间，一般只在二分类的最后输出层使用。主要缺陷为存在梯度消失问题，计算复杂度高，输出不以0为中心。 tf.nn.softmax：sigmoid的多分类扩展
阅读全文
摘要：class Solution: def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: res = [] path = [] n = len(candidates) candidates.so
阅读全文
摘要：#本次采用pytorch实现 #探究房屋状况的俩个因素,房龄和面积 #公式 price = w(area)*area+w(age)*age+b #损失函数:用于衡量价格预测值与真实值之间的误差,通常我们会选取一个非负数作为误差，且数值越小表示误差越小 #优化函数 ->直接用公式表达出来。这类解叫作解
阅读全文
摘要：#前者为Variable的案例 #后者为Session import tensorflow as tf tf.compat.v1.disable_eager_execution() state = tf.Variable(0, name='counter') # 定义常量 one one = tf.
阅读全文
摘要：import tensorflow as tf import numpy as np import tensorflow.compat.v1 as tf tf.disable_v2_behavior()# 由于部分代码含有版本不同,此将v2版本禁用使用v1版本 # create data x_dat
阅读全文
摘要：#一个判断函数,一个填数函数 #开始本来想就36进行改,但其参数有限,重新判断(其中将分为9个大块) class Solution: def solveSudoku(self, board: List[List[str]]) -> None: """ Do not return anything,
阅读全文
摘要：#暴力破解 # 数字 1-9 在每一行只能出现一次。 # 数字 1-9 在每一列只能出现一次。 # 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次 class Solution: def isValidSudoku(self, board: List[List[str]]) -> b
阅读全文
摘要：#two demos #deme 01 import tensorflow as tf mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test =
阅读全文
摘要：tf.keras.models.Sequential()用法 by Markdown Sequential()方法是一个容器，描述了神经网络的网络结构，在Sequential()的输入参数中描述从输入层到输出层的网络结构 使用方法：model = tf.keras.models.Sequential
阅读全文
摘要：#Markdown笔记 ~~一定不会忘记的~~ 1.有序列表 2.* 无序列表 * 3.添加引用 4.code 代码快 5.分割线 6.链接 title https://www.cnblogs.com/158-174/ 可点击的链接 可以查看我的博客 强调链接 7.图片 ！请看波吉王子 8.脚注 [
阅读全文
摘要：#很简单的一道双指针题目，就不做详细解释了 class Solution: def search(self, nums: List[int], target: int) -> int: left,right = 0,len(nums)-1 if not nums: return -1 while l
阅读全文
摘要：暴力解法，俩次循环第一次记录（的每个下标，再分别做判断 class Solution: def longestValidParentheses(self, s: str) -> int: lg = len(s) nums = [i for i in range(lg) if s[i] == '(']
阅读全文
摘要：常见机器学习算法 from sklearn import svm, tree, linear_model, neighbors, naive_bayes, ensemble, discriminant_analysis, gaussian_process from xgboost import XG
阅读全文
摘要：#简单梳理下题意：比如给你3421这个数，那要在保证有上升且上升幅度最小，那就是4321了 #如果没法上升，就返回最小的1234 class Solution: def nextPermutation(self, nums: List[int]) -> None: """ Do not return
阅读全文
摘要：#暴力解法 #子序列：可以不连续 #子串：必须连续 class Solution: def findSubstring(self, s: str, words: List[str]) -> List[int]: from collections import Counter #Python coun
阅读全文
摘要：#导入库 import numpy as np import pandas as pd import random from datetime import datetime from matplotlib import pyplot as plt import seaborn as sns fro
阅读全文
摘要：#笑话来咯 import math class Solution: def divide(self, dividend: int, divisor: int) -> int: ans = dividend / divisor if dividend / divisor < 2147483648 el
阅读全文
摘要：# 有点问题，解决了数组越界后但还是发生错误，待解决 class Solution: def strStr(self, haystack: str, needle: str) -> int: if not needle: return 0 if len(needle)>len(haystack):
阅读全文
摘要：#还是双指针，与上一道题相似 class Solution: def removeElement(self, nums: List[int], val: int) -> int: fast,slow = 0,0 while fast<len(nums): if nums[fast]!=val: nu
阅读全文
摘要：#遍历一遍，快慢指针 class Solution: def removeDuplicates(self, nums: List[int]) -> int: pre,cur=0,1 while cur<len(nums): if nums[pre]==nums[cur]: nums.pop(cur)
阅读全文
摘要：#递归的思路 #最初思路是把该链表分为以k为基数的组，然后每组进行reverse #而每组其实构造是一致的，利用递归即可解决 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next
阅读全文
摘要：#迭代 #1.point.next = swap2 #2.swap1.next = swap2.next #3.swap2.next = swap1 # Definition for singly-linked list. # class ListNode: # def __init__(self,
阅读全文
摘要：#本次采用Kmans分析数据 import pandas as pd import numpy as npp from matplotlib import pyplot as plt from sklearn.cluster import KMeans import matplotlib impor
阅读全文
摘要：#能不动脑子咱就不动,暴力解法 #将链表元素放置数组中 #进行排序 #生成新链表 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = v
阅读全文
摘要：# dfs的遍历 class Solution: def generateParenthesis(self, n: int) -> List[str]: if n <= 0: return [] # 特例判断 res = [] #设置返回列表 def dfs(paths, left, right):
阅读全文
摘要：#递归解法 class Solution: def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]: if not list1: return list2#
阅读全文
摘要：import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import datetime as dt import warnings warnings.filterwarn
阅读全文
摘要：#利用栈的特性，先进后处，刚好进行比较，{[()]}分别进行比较 class Solution: def isValid(self, s: str) -> bool: stk = [] for c in s: # 如果c是 ({[ 则入栈 if c in ['(','[','{']: stk.app
阅读全文
摘要：#循环迭代 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solutio
阅读全文
摘要：#三数之和双指针循环外再加一个循环，但有些细节还是在里面的，需注意 def fourSum(self, nums: List[int], target: int) -> List[List[int]]: res = [] #设置空列表做返回值 if len(nums)<4 : return res
阅读全文
摘要：# 本次采用KNN算法进行解析 import numpy as np import pandas as pd import matplotlib.pyplot as plt import warnings warnings.filterwarnings('ignore') #用于忽略由于版本更新等不
阅读全文
摘要：#dfs(深度优先遍历) #将数字转为字典格式 #定义dfs函数(本质上回溯问题)，遍历dic[digit]返回值为dfs()函数，达到遍历的目的 #ps：由于存在空字符串的情况，必须设置加入条件！='' def letterCombinations(self, digits: str) -> Li
阅读全文
摘要：#暴力解法，直接三重循环 def threeSumClosest(self, nums: List[int], target: int) -> int: sub = 999999999999 sum = 0 for i in range(len(nums)): for j in range(i+1,
阅读全文
摘要：#双指针，注意排除重复值，比如[2,2]那么指针就要往前或者后移 def threeSum(self, nums: [int]) -> [[int]]: nums.sort()#从小到大排序 res, k = [], 0 for k in range(len(nums) - 2): if nums[
阅读全文
