2019 年 12月随笔档案 - Sempron2800+

leetcode1300

摘要：参考：https://leetcode.com/problems/sum-of-mutated-array-closest-to-target/discuss/464211/Python-Binary-Search 补充另一个，使用Java实现的代码，可读性好一些：参考：https://leetc 阅读全文

posted @ 2019-12-29 17:15 Sempron2800+ 阅读(222) 评论(0) 推荐(0) 编辑

leetcode1302

摘要：算法思想：二叉树层次遍历。阅读全文

posted @ 2019-12-29 14:09 Sempron2800+ 阅读(179) 评论(0) 推荐(0) 编辑

leetcode1299

摘要：从右向左遍历，每次更新右区间的最大值maxright，并将这个值插入结果数组的0下标位置。阅读全文

posted @ 2019-12-29 13:56 Sempron2800+ 阅读(148) 评论(0) 推荐(0) 编辑

leetcode1306

摘要：算法思路：BFS。先记录所有的0值元素的下标，作为初始集合。使用两层遍历，找出每到每个可达点存入下一层的集合。使用visited进行缓存，过滤重复访问过的点，防止出现环，而死循环。阅读全文

posted @ 2019-12-29 11:20 Sempron2800+ 阅读(164) 评论(0) 推荐(0) 编辑

leetcode1305

摘要：分别使用中序遍历两颗二叉搜索树，得到两个有序列表。再将两个数组合并为一个有序数组。阅读全文

posted @ 2019-12-29 11:17 Sempron2800+ 阅读(166) 评论(0) 推荐(0) 编辑

leetcode1304

摘要：1 class Solution: 2 def sumZero(self, n: int) -> List[int]: 3 res = [] 4 k = n // 2 5 i = 1 6 for j in range(k): 7 res.append(i) 8 res.append(i * (-1)) 9 i += 1 10 if n % 2 == 1: 11 res.append(0) 12 r 阅读全文

posted @ 2019-12-29 11:16 Sempron2800+ 阅读(129) 评论(0) 推荐(0) 编辑

设计模式23 解释器模式

摘要：解释器模式(Interpreter)定义：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。解释器模式的优点有： 1、扩展性好。由于在解释器模式中使用类来阅读全文

posted @ 2019-12-28 11:20 Sempron2800+ 阅读(140) 评论(0) 推荐(0) 编辑

设计模式22 备忘录模式

摘要：备忘录模式(Memento)定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式。备忘录模式的优点有： 1、提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。 2、实现阅读全文

posted @ 2019-12-28 11:19 Sempron2800+ 阅读(147) 评论(0) 推荐(0) 编辑

设计模式21 访问者模式

摘要：直观对比一下两种设计模式，左图：访问者模式；右图：策略模式。可发现，访问者模式相当于两个策略模式的“并联”。访问者模式(Visitor)定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问阅读全文

posted @ 2019-12-28 11:18 Sempron2800+ 阅读(200) 评论(0) 推荐(0) 编辑

设计模式20 迭代器模式

摘要：迭代器模式(Iterator)定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式的优点有： 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、遍历任务交由迭代器完成，这简化了聚合类。 3、它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新阅读全文

posted @ 2019-12-28 11:17 Sempron2800+ 阅读(154) 评论(0) 推荐(0) 编辑

设计模式19 中介者模式

摘要：中介者模式(Mediator)定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。中介者模式的优点有： 1、降低了对象之间的耦合性，使得对象易于独立地被复用。 2、将对象间的一对多关联转变为一阅读全文

posted @ 2019-12-28 11:16 Sempron2800+ 阅读(153) 评论(0) 推荐(0) 编辑

设计模式18 观察者模式

摘要：直观对比一下两种设计模式，左图：观察者模式；右图：策略模式。可以看到观察者模式的“下部分”就是策略模式。观察者模式(Observer)定义：指多个对象间存在一对多的依赖关系(主题是“一”，观察者是“多”)，当一个(主题)对象的状态发生改变时，所有依赖于它的(观察者)对象都得到通知并被自动更新。这种阅读全文

posted @ 2019-12-28 11:15 Sempron2800+ 阅读(165) 评论(0) 推荐(0) 编辑

设计模式17 状态模式

摘要：首先直观对比一下两种模式，左图：状态模式；右图：策略模式。可以看出，状态模式是在策略模式的基础上，增加了状态类对环境类的“反向调用”。状态模式(State)定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。状态模式的优点有： 1、状态阅读全文

posted @ 2019-12-28 11:14 Sempron2800+ 阅读(101) 评论(0) 推荐(0) 编辑

设计模式16 责任链模式

摘要：责任链模式(ChainOfResponsibility)定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。责任链模式的优点有： 1、降低了对象之间的耦合度。该模式使得一阅读全文

posted @ 2019-12-28 11:13 Sempron2800+ 阅读(140) 评论(0) 推荐(0) 编辑

设计模式15 命令模式

摘要：命令模式与策略模式的UML类图比较接近，先直观的对比一下。左图：命令模式，右图：策略模式。可以看出，命令模式的“上部分”就是策略模式，是在策略模式的基础上，增加了receiver类型。命令模式(Command)定义：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通阅读全文

posted @ 2019-12-28 11:11 Sempron2800+ 阅读(166) 评论(0) 推荐(0) 编辑

设计模式13 模板方法模式

摘要：模板方法模式(TemplateMethod)定义：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。模板方法模式的优点有： 1、它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而阅读全文

posted @ 2019-12-28 11:10 Sempron2800+ 阅读(129) 评论(0) 推荐(0) 编辑

设计模式14 策略模式

摘要：策略模式(Strategy)定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。策略模式的优点： 1、多重条件语句不易阅读全文

posted @ 2019-12-28 11:10 Sempron2800+ 阅读(238) 评论(0) 推荐(0) 编辑

设计模式12 组合模式

摘要：组合模式定义：组合模式又叫作“部分-整体”模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系。使用户对单个对象和组合对象具有一致的访问性。如图左边是：组合模式；右边是：装饰者模式。可见组合模式就是装饰者模式的上半部分。组合模式的优点有： 1、组合模式使得客户端代码可以阅读全文

posted @ 2019-12-28 11:09 Sempron2800+ 阅读(158) 评论(0) 推荐(0) 编辑

设计模式11 享元模式

摘要：享元模式定义：运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。享元可以理解为“共享元件”。享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带阅读全文

posted @ 2019-12-28 11:08 Sempron2800+ 阅读(141) 评论(0) 推荐(0) 编辑

设计模式10 外观模式

摘要：外观模式(Facade)定义：是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。外观模式的优点有： 1、降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。 2、对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。阅读全文

posted @ 2019-12-28 11:07 Sempron2800+ 阅读(109) 评论(0) 推荐(0) 编辑

设计模式09 装饰模式

摘要：装饰模式(Decorator)定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。这里的“不改变现有对象结构”主要是指“使用的是同一个对象”。装饰模式的优点有： 1、采用装饰模式扩展对象的功能比采用继承方式更加灵活。 2、可以设计出多个不同的具体装饰类，创阅读全文

posted @ 2019-12-28 11:07 Sempron2800+ 阅读(152) 评论(0) 推荐(0) 编辑

设计模式08 桥接模式

摘要：桥接模式(Bridge)定义：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。如上图所示，平直的那条"聚合关系"就像一座桥一样。实现部分：抽象部分：调用方式：执行结果：阅读全文

posted @ 2019-12-28 11:06 Sempron2800+ 阅读(144) 评论(0) 推荐(0) 编辑

设计模式06 代理模式

摘要：代理模式(Proxy)定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。代理模式的优点有： 1、代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用； 2、代理对象可以扩展目标对象的阅读全文

posted @ 2019-12-28 11:05 Sempron2800+ 阅读(149) 评论(0) 推荐(0) 编辑

设计模式07 适配器模式

摘要：左图是：对象结构型适配器模式；右图是：类结构型适配器模式。常用的是第一种方式。对象结构型适配器模式与代理模式的UML类图比较接近，对比的看一下：左图是：对象结构型适配器模式；右图是：代理模式。适配器模式，可以看作是简化的代理模式，Adaptee无需实现Target接口。适配器模式的本质就是：A 阅读全文

posted @ 2019-12-28 11:05 Sempron2800+ 阅读(110) 评论(0) 推荐(0) 编辑

设计模式05 建造者模式

摘要：建造者模式(Builder)定义：将一个复杂对象的构造与其表示分离，使同样的构造过程可以创建不同的表示。它将一个复杂的对象分解为多个简单对象，然后一步一步构建这个对象。所构造的对象的组成部分(数量、顺序)不变，而每一个组成部分的具体内容是可变的。建造者模式的优点： 1、各个具体的建造者相互独立。阅读全文

posted @ 2019-12-28 11:04 Sempron2800+ 阅读(124) 评论(0) 推荐(0) 编辑

设计模式03 工厂方法模式

摘要：工厂方法模式(FactoryMethod)定义：定义一个用于创建对象(产品对象)的接口，称之为工厂，由实现了这个工厂接口的具体类来创建对象(产品对象)。工厂方法模式的优点是：可以方便的添加新的产品对象，而不用修改原来的代码，满足开闭原则。如UML类图所示，目前有ProductA和ProductB 阅读全文

posted @ 2019-12-28 11:03 Sempron2800+ 阅读(108) 评论(0) 推荐(0) 编辑

设计模式04 抽象工厂模式

摘要：先直观对比一下抽象工厂模式(上图)，与工厂方法模式(下图)的UML类图的区别。可以看出：工厂方法模式是一个工厂接口，即多个工厂生产一种(等级)产品；而抽象工厂模式是多个工厂接口，多个工厂生产多种(等级)产品。抽象工厂模式(AbstractFactory)定义：提供一个称为抽象工厂的接口，其每一阅读全文

posted @ 2019-12-28 11:03 Sempron2800+ 阅读(237) 评论(0) 推荐(0) 编辑

设计模式02 原型模式

摘要：原型模式(Prototype)定义：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在Java中，通过实现Cloneable接口中的clone()方法，可以方便的实现原型模式，具体代码如下：原型类： 1 public class Realizetype imp 阅读全文

posted @ 2019-12-28 11:02 Sempron2800+ 阅读(162) 评论(0) 推荐(0) 编辑

设计模式01 单例模式

摘要：单例模式(Singleton)定义：一个类只能有一个实例，且该类能自行创建这个实例的模式。单例模式有三个特点： 1、单例类只有1个实例对象。 2、该单例对象必须由单例类自己创建。 3、单例类对外提供一个访问该唯一实例的全局访问点。懒加载实现，线程安全： 1 public class LazySi 阅读全文

posted @ 2019-12-28 11:00 Sempron2800+ 阅读(145) 评论(0) 推荐(0) 编辑

leetcode1297

摘要：算法思路：滑动窗口。窗口的范围是[minSize,maxSize]之间，left从左到右遍历，每次得到一个right。统计left到right这个窗口内的元素，有多少个不同元素，是否满足maxLetters限制。如果满足条件则存储进res中，最后返回res出现次数最多的值(value)。阅读全文

posted @ 2019-12-22 13:31 Sempron2800+ 阅读(144) 评论(0) 推荐(0) 编辑

leetcode1296

摘要：算法思路：贪心。先将数组排序，然后按照顺序添加到顺序字典中。另记录一个key值从小到大的列表。每次从key列表中选择最小的元素，作为组头，当前组的剩余k-1个元素，依次+1。如果不满足这个条件，则返回False。如果全部的元素都能分配到对应的组中，就表示符合题意。阅读全文

posted @ 2019-12-22 13:26 Sempron2800+ 阅读(153) 评论(0) 推荐(0) 编辑

leetcode1295

摘要：1 class Solution: 2 def findNumbers(self, nums: List[int]) -> int: 3 n = len(nums) 4 count = 0 5 for i in range(n): 6 s = str(nums[i]) 7 if len(s) ... 阅读全文

posted @ 2019-12-22 13:21 Sempron2800+ 阅读(203) 评论(0) 推荐(0) 编辑

leetcode1291

摘要：按照从小到大的顺序生成递增序列，每生成一个序列，判断是否在限定区间内。如果超过了区间的上限，则跳过本轮循环(因为后面的值会更大)。阅读全文

posted @ 2019-12-15 15:29 Sempron2800+ 阅读(141) 评论(0) 推荐(0) 编辑

leetcode1292

摘要：这道题暴力法会TLE，先给出这种TLE方案：使用前序和方式，Java的可以AC，但是python仍然会TLE，给出这种TLE方案：参考：https://leetcode.com/problems/maximum-side-length-of-a-square-with-sum-less-than 阅读全文

posted @ 2019-12-15 13:08 Sempron2800+ 阅读(305) 评论(0) 推荐(0) 编辑

leetcode1290

摘要：1 class Solution: 2 def getDecimalValue(self, head: ListNode) -> int: 3 res = 0 4 lists = [] 5 while head != None: 6 lists.append(head.val) 7 head = head.next 8 pos = 0 9 for i in range(len(lists)-1,- 阅读全文

posted @ 2019-12-15 12:58 Sempron2800+ 阅读(152) 评论(0) 推荐(0) 编辑

leetcode931

摘要：是leetcode1289的基础版本，与leetcode120的思想基本一致。阅读全文

posted @ 2019-12-15 01:28 Sempron2800+ 阅读(226) 评论(0) 推荐(0) 编辑

leetcode1289

摘要：本题是leetcode 931的升级版，如果直接计算每一行和其上面每一行中不在同一列的和，会TLE。因此只保留上一行最小的2个数字。在计算当前行时，只需要判断当前单元格的列是否与前一行的最小值在同一列，如果在同一列，则使用倒数第二小的值。否则就使用上一行的最小值。下面是TLE的方案，可以作为对比阅读全文

posted @ 2019-12-15 01:26 Sempron2800+ 阅读(169) 评论(0) 推荐(0) 编辑

leetcode1286

摘要：直接调用itertools内置函数，快速生成符合条件的组合。 1286. Iterator for Combination 阅读全文

posted @ 2019-12-15 01:19 Sempron2800+ 阅读(139) 评论(0) 推荐(0) 编辑

leetcode1288

摘要：并查集思想，将可以被合并的(范围小的)区间标记，最后没有标记的就是所求的个数。另一种思路，先排序再比较，效率更高：参考：https://leetcode.com/problems/remove-covered-intervals/discuss/451532/Python3-O(n*logn)- 阅读全文

posted @ 2019-12-15 01:17 Sempron2800+ 阅读(150) 评论(0) 推荐(0) 编辑

leetcode1287

摘要：1 class Solution: 2 def findSpecialInteger(self, arr: List[int]) -> int: 3 n = len(arr) 4 dic = {} 5 for i in range(n): 6 if arr[i] not in dic: 7 ... 阅读全文

posted @ 2019-12-15 01:16 Sempron2800+ 阅读(137) 评论(0) 推荐(0) 编辑

leetcode133

摘要：算法思路：BFS 参考：https://leetcode.com/problems/clone-graph/discuss/440722/Python-3-BFS 阅读全文

posted @ 2019-12-11 14:04 Sempron2800+ 阅读(143) 评论(0) 推荐(0) 编辑

leetcode137

摘要：1 class Solution: 2 def singleNumber(self, nums: 'List[int]') -> int: 3 dic = {} 4 for n in nums: 5 if n not in dic: 6 dic[n] = 1 7 else: 8 dic[n] += 1 9 for k,v in dic.items(): 10 if v == 1: 11 retur 阅读全文

posted @ 2019-12-11 13:59 Sempron2800+ 阅读(123) 评论(0) 推荐(0) 编辑

leetcode120

摘要：初始化dp所有单元格为maxsize值，定义dp[1][1]表示第一层第一列，是三角中的顶部元素2。从第二行开始，每个单元格取其左上角和正上方两个单元格中的较小的值，再加上当前节点的值。则最后一行中的最小值，即为所求。阅读全文

posted @ 2019-12-11 13:53 Sempron2800+ 阅读(175) 评论(0) 推荐(0) 编辑

leetcode129

摘要：1 class Solution: 2 def __init__(self): 3 self.lists = [] 4 5 def preOrder(self,root,path): 6 if root != None: 7 path.append(str(root.val)) 8 ... 阅读全文

posted @ 2019-12-11 13:16 Sempron2800+ 阅读(157) 评论(0) 推荐(0) 编辑

leetcode143

摘要：先找到链表的中间节点，然后从中间节点将链表一分为二。将后半部分的节点倒序。然后轮流从两个链表中选择节点连接在一起。参考：https://leetcode.com/problems/reorder-list/discuss/447242/python-solution 阅读全文

posted @ 2019-12-11 13:04 Sempron2800+ 阅读(139) 评论(0) 推荐(0) 编辑

leetcode147

摘要：1 class Solution: 2 def constructLink(self,lists): 3 n = len(lists) 4 if n == 0: 5 return None 6 if n == 1: 7 return ListNode(lists[0]) 8 ... 阅读全文

posted @ 2019-12-11 12:54 Sempron2800+ 阅读(117) 评论(0) 推荐(0) 编辑

leetcode187

摘要：1 class Solution: 2 def findRepeatedDnaSequences(self, s: str) -> 'List[str]': 3 n = len(s) 4 if n 1: 20 res.append(k) 21 return res 阅读全文

posted @ 2019-12-11 12:34 Sempron2800+ 阅读(140) 评论(0) 推荐(0) 编辑

leetcode117

摘要：本题和leetcode116的区别是，116题是完全二叉树，本题是普通二叉树(不一定是完全二叉树)。但当初做116题的时候，并没有使用完全二叉树这个条件，因此当初的解决方案，完全适用于本题。阅读全文

posted @ 2019-12-11 11:56 Sempron2800+ 阅读(169) 评论(0) 推荐(0) 编辑

leetcode106

摘要：本题与leetcode105是同一类的问题。 leetcode105是使用前序和中序构建二叉树，本题是使用中序和后序构建二叉树。注意，前、中、后三种序列中，只需中序和另外任意一种序列，即可构建二叉树。但是只有前序和后序是无法唯一确定二叉树结构的。阅读全文

posted @ 2019-12-11 11:27 Sempron2800+ 阅读(220) 评论(0) 推荐(0) 编辑

leetcode199

摘要：二叉树层次遍历，最后返回每一层的最后一个节点组成的集合。阅读全文

posted @ 2019-12-11 11:09 Sempron2800+ 阅读(157) 评论(0) 推荐(0) 编辑

leetcode113

摘要：本题是leetcode112的升级版，需要检查多条路径，并保存。阅读全文

posted @ 2019-12-11 10:31 Sempron2800+ 阅读(139) 评论(0) 推荐(0) 编辑

leetcode173

摘要：1 class BSTIterator: 2 def __init__(self, root: TreeNode): 3 self.lists = [] 4 self.idx = 0 5 self.size = 0 6 self.inOrder(root) 7 8 def inOrder(self,root): 9 if root != None: 10 if root.left != None: 阅读全文

posted @ 2019-12-11 10:14 Sempron2800+ 阅读(153) 评论(0) 推荐(0) 编辑

leetcode89

摘要：这是一道数学题，参考：https://leetcode.com/problems/gray-code/discuss/445279/Python-solution 不了解这个数学原理的，面试时很难做出来。阅读全文

posted @ 2019-12-11 10:03 Sempron2800+ 阅读(195) 评论(0) 推荐(0) 编辑

leetcode60

摘要：流程分析，以(4,9)为例： 4 * 3 * 2 * 1 = 24 第一位数字的选择按 3 * 2 * 1 = 6 个为一组，共24个，则分4组1-6 第一组7-12 第二组13-18 第三组19-24 第四组被除数为9，除数为69 // 6 = 19 % 6 = 3 > 0 因此9 是第二组在 1 阅读全文

posted @ 2019-12-11 08:47 Sempron2800+ 阅读(176) 评论(0) 推荐(0) 编辑

leetcode165

摘要：1 class Solution: 2 def compareVersion(self, version1: str, version2: str) -> int: 3 ary1 = version1.split('.') 4 ary2 = version2.split('.') 5 n1,n2 = len(ary1),len(ary2) 6 i,j = 0,0 7 while i < n1 an 阅读全文

posted @ 2019-12-10 22:46 Sempron2800+ 阅读(131) 评论(0) 推荐(0) 编辑

leetcode63

摘要：在leetcode62的基础上，增加对障碍物的判断。阅读全文

posted @ 2019-12-10 22:31 Sempron2800+ 阅读(157) 评论(0) 推荐(0) 编辑

leetcode92

摘要：1 class Solution: 2 def constructLink(self,lists): 3 n = len(lists) 4 if n == 0: 5 return None 6 if n == 1: 7 return ListNode(lists[0]) 8 9 head = ListNode(lists[-1]) 10 for i in range(n-2,-1,-1): 11 阅读全文

posted @ 2019-12-10 20:07 Sempron2800+ 阅读(158) 评论(0) 推荐(0) 编辑

leetcode86

摘要：将链表中的节点，按照x值分别存储到两个集合中，再用重新拼接的集合建立链表。阅读全文

posted @ 2019-12-10 19:48 Sempron2800+ 阅读(145) 评论(0) 推荐(0) 编辑

leetcode82

摘要：1 import collections 2 class Solution: 3 def constructLink(self,lists): 4 n = len(lists) 5 if n == 0: 6 return None 7 if n == 1: 8 return L... 阅读全文

posted @ 2019-12-10 18:19 Sempron2800+ 阅读(220) 评论(0) 推荐(0) 编辑

leetcode81

摘要：1 class Solution: 2 def search(self, nums: 'List[int]', target: int) -> bool: 3 n = len(nums) 4 if n == 0: 5 return False 6 if n == 1: 7 ret... 阅读全文

posted @ 2019-12-10 18:06 Sempron2800+ 阅读(127) 评论(0) 推荐(0) 编辑

leetcode80

摘要：算法思想：双指针。 i记录应该插入的位置，j是当前搜索的位置。阅读全文

posted @ 2019-12-10 16:35 Sempron2800+ 阅读(178) 评论(0) 推荐(0) 编辑

leetcode71

摘要：使用栈存储，在遇到 '..'的时候出栈，在遇到目录的时候入栈，遇到空白字符或者'.'的时候不处理。阅读全文

posted @ 2019-12-10 16:14 Sempron2800+ 阅读(126) 评论(0) 推荐(0) 编辑

leetcode151

摘要：与剑指Offer 58题相似，增加了对空白字符的处理。阅读全文

posted @ 2019-12-10 13:12 Sempron2800+ 阅读(133) 评论(0) 推荐(0) 编辑

leetcode61

摘要：先将原来的链表展开，存储到数组中，并计算数组长度。再将数组按照k值翻转，重新排好顺序。最后使用尾插法，重建链表。将复杂问题分开步骤处理，可以使代码更清晰。阅读全文

posted @ 2019-12-10 12:58 Sempron2800+ 阅读(127) 评论(0) 推荐(0) 编辑

leetcode74

摘要：先按照列进行二分查找，找到符合的行，再对这一行进行二分查找。阅读全文

posted @ 2019-12-10 10:37 Sempron2800+ 阅读(159) 评论(0) 推荐(0) 编辑

leetcode59

摘要：本题思路同leetcode54一样，二维数组螺旋遍历。起点坐标：沿主对角线，从左上向右下移动，即 x += 1, y += 1 终点坐标：每次缩小n的范围，即 n -= 1 能完整访问一个"外圈"，就可以按照相同的方式，访问"内圈"，一层一层的访问。阅读全文

posted @ 2019-12-10 09:40 Sempron2800+ 阅读(198) 评论(0) 推荐(0) 编辑

leetcode1283

摘要：算法思想：二分查找。从1到nums中的最大值，作为左右边界。进行二分查找。 target默认为nums中的最大值，这样保证除数之和最小。(此时r=1 * n) 每次以mid作为除数计算目标值，并根据目标值与threshold的比较，进行二分查找。注意第7行的判断条件是 l <= h。阅读全文

posted @ 2019-12-08 11:37 Sempron2800+ 阅读(286) 评论(6) 推荐(0) 编辑

leetcode1282

摘要：哈希思想，在dic中记录每一种size对应的元素的集合。然后按照size的大小进行分组，每个子集中都包含size个元素。阅读全文

posted @ 2019-12-08 11:32 Sempron2800+ 阅读(201) 评论(0) 推荐(0) 编辑

leetcode1281

摘要：一次循环，同时记录乘积与加和。循环结束，两值再相减。阅读全文

posted @ 2019-12-08 11:29 Sempron2800+ 阅读(161) 评论(0) 推荐(0) 编辑

leetcode109

摘要：这道题是leetcode108的升级版，先将单链表转化成数组，然后再根据数组生成高度平衡二叉搜索树。阅读全文

posted @ 2019-12-03 09:58 Sempron2800+ 阅读(120) 评论(0) 推荐(0) 编辑

leetcode1277

摘要：和题目leetcode221思路一样，只有第13行和14行不同。阅读全文

posted @ 2019-12-01 12:14 Sempron2800+ 阅读(160) 评论(0) 推荐(0) 编辑

leetcode1276

摘要：以 cheese为基础，假设全部都是小的，则需要 2 * cheese 个tomato，记为 tomato_low假设全部都是大的，则需要 4 * cheese 个tomato，记为 tomato_high 先判断提供的tomato是否在这个区间内，如果不在这个区间内，则返回[]在这个区间内。阅读全文

posted @ 2019-12-01 12:12 Sempron2800+ 阅读(157) 评论(0) 推荐(0) 编辑

leetcode1275

摘要：使用多个变量，存储行、列、对角线、反对角线等信息。阅读全文

posted @ 2019-12-01 12:06 Sempron2800+ 阅读(171) 评论(0) 推荐(0) 编辑

leetcode1272

摘要：分6种情况讨论（第一个if语句是两种情况）阅读全文

posted @ 2019-12-01 09:34 Sempron2800+ 阅读(178) 评论(0) 推荐(0) 编辑

leetcode1271

摘要：1 class Solution: 2 def toHexspeak(self, num: str) -> str: 3 dic = {'a':'A','b':'B','c':'C','d':'D','e':'E','f':'F','1':'I','0':'O'} 4 dn_10 = int(num) 5 dn_16 = hex(dn_ 阅读全文

posted @ 2019-12-01 08:52 Sempron2800+ 阅读(151) 评论(0) 推荐(0) 编辑

搜索

我的标签

随笔档案

阅读排行榜