2023.7.9 CS课程 扫二维码继续学习 二维码时效为半小时

(0评价)
价格: 99999.00元

有状态的计算:每时每刻都存在一个状态,  eg,天猫的成交额每时每刻。

文件和数据库:  关系型数据库存储大量的描述性词语文件。  eg:key,  szie,  path,

 

单机服务器的优点:易于维护,没有网络故障,本地保存,

缺点:szie不够大,安全性容错性低,机器挂了,整个服务寄了

 

应用服务和数据服务分离:分成3个服务器,应用,文件,数据库服务器。  

 

提高了负载能力,和容灾能力。

问题:重复访问的话有重复的请求,都要数据库找path,然后文件服务器进行拼接文件片段返回目的文件。  每次操作都要同样进行,导致速度降低。

因此用到缓存,加快访问速度。  本地缓存和分布式缓存。 前者速度快,容量有限。 后者无限容量。

eg。病毒检测结果也可以存到缓存里,不用重复检测同样的地方。

 

负载均衡调节器,常用Nginx。

 

数据库服务器:主从。  从进行读,主进行写,然后主从复制。

 

CDN,内容分发网络,根据用户地址调配距离最近的服务器提高响应速度。

 

 

 

 

 

  • transcation driven

 

事务驱动,eg:  打车软件,外卖软件,  有不同的模块“pay, order。。。”都是跟client进行联系。  两两之间也有rest api等进行联系(用户看不到)

 

CAP原理:consistent, availability,partition tolerance。

不同服务器中一致性,可获得性,一直有响应,  某台机器挂掉,剩下的机器也能用。

 

3个之中只能有2个:  CP:金融系统,强一致性, A不行因为要所有机器奔跑起来检车一致后才能响应。

 

AP: 某些机器挂了,可以先提供本地副本,所以牺牲了一致性。eg:买东西:看的时候有库存,但付款发现没有库存,

 

transaction:  事务性应用,买东西:order,inventory,payment,三则同时成功或者同时失败。

 

但是缺点是eg:  实时流计算:每秒有很多请求,不同请求,不能完成数据量非常大的应用,无法进行数据聚集(付款方式,付款人名字。。。)。

 

  • event-driven 驱动

是从event log里面,不需要知道很多的信息:姓名,付款方式etc。  

现在是event trigger action 来write到log,然后产生其他的application

 

OLAP:  online analytical  processing。

 

eg:8/1  8/30的数据汇总分析。

如果定义状态,每天就可以知道每天的数据分析和任务操作,这样9/1就可以直接方便知道

 

 

 

[展开全文]
shaning · 02-11 · 0

regular expression

 

 

[展开全文]
shaning · 02-07 · 0

script和非script区别

:脚本编译和运行一起,跑一行一行

。  c++等先编译在运行

 

 

extraction-based summarization算法

abstracion-based summarization

text-rank

youtube 字幕api

[展开全文]
shaning · 02-07 · 0

BERT

07: ATTention 论文

getgpt

theb

test_chat_completion.py.  stream:flase

[展开全文]
shaning · 02-06 · 0

duplicate 副本

 aurora 30秒还是会造成一小部分数据缺失

 

SWF。simple。work。flow

 

横向发展:多买机器,。纵向发展、单个机器rong liang

事务机制:同时成功或者fail, 比如说银行转帐

 

 

N o s q l

[展开全文]
shaning · 01-16 · 0

dynamoDB

S3

react :HTML,Javascript,菜鸟教程

[展开全文]
shaning · 01-14 · 0
  • 进阶链表
  • 进阶树
  • 进阶图

 

  • 进阶链表

双向链表,

例题 430  .   dfs即可

 

异或链表

 

  • 进阶树

segement  tree

,  节点里面能存储区间

 

303.  问题在于如果调用很多次怎么办,可以用新的存储空间来存储,

 

Trie: 字典树

 

平衡树

 

N 叉树

 

B树 

 

红黑树

[展开全文]
shaning · 01-08 · 0

maimimum moving avarage:

 

maimimum moving max:

:可以一用heap么。不可以,因为不知道pop的是不是头

:可以用sorted stack

:思路:,squential,,,每到一个ele时,有可能时后面max,所以先判断前面《的话,删掉然后加上本个ele,》的话直接加上,因为stack村的是有可能是max的东西。  如果move 后out of window,先删除对应操作,这样stack顶永远是max当前window。   

这样用的就是deque,或者double linklist,

out of window 的时候要注意判断头部是不是out? index stack:记录index,,然后j-i>=k,就是out  of window

 

dfs  stack的模板:

DFS(s,g):

   stack s,

   end constraint g,

  initilaize s:  push first node to s and visited hashet, parent hashmap.

  while(stack not empty:){

            pop node;

           if(cur==G) return 

           for (each neighburs not visited){

                 add neighvbut to visited

                add cur as parent of n

               push n onto stack

 

 

 

 

 

  • 图论

1.Maze  ,  2D array,  赵路径

例题:maze II。

 

使用的三个数据结构:“hash set, bisited”"hahmap,path"  "stack或者queue"

 

C++中可以用vector<bool>也可以待变visited

看题目要求是不是要path,如果去找neighbour,  

 

Maze中可以用i,j+-1,或者用一个direction矩阵代表更多方向,然后for循环去迭代方向

 

2. 2D array   all points

 

flood fill.    填色

 

思路:single point dfs/bfs都可以,  时间complexity都一样  |V|+|E|.

dfs  的recursion的代码量简洁。

 

 

例题:number of island。

思路,for矩阵,然后dfs开始,碰到1就边0,然后整体计算number

,all points 的dfs就是for single point的dfs

   

3。 friend circles,  邻接矩阵,像但由于是一个对角线的all points

可以用dfs找path,如果能有一条path,说明一个circle,没有说明第二个circle

for  i  是代表人,利用visted代表circle,dfs之后count++就是circle的数量

 

 

4.  例题:pacific atlantic water flow.

还可以用dp的结果,避免重复计算

,可以:aLL points+DP

DP里面不同的值来代表不同的意思

还要回溯,底部true,回溯回去也要true,一路的retrun

selected point:

 

 

5. non 2D array   

 

例题:word ladder

 

思路:每个word是一个vertex,

可以用stack。

要解决的问题:neighbour,hashset,hahmap,start

这里难点在于如何判断neighbour,

 

思路,可以对于当前单词进行每个位置的字母改变,然后find 字典里是否有出现。

 

BFS可以求最短路径

[展开全文]
shaning · 01-07 · 0
  • sliding window

属于2 pointer的子集,都是从前往后走

例题:remove duplicated from sorted array

思路:end往后走直到最后一个different。然后start是第一个diff, 所以in place的算法是吧dif的ele move到start,start+1.

so  start: is the first distinct的position

end是来判断,if dif的话就跟start换位置,if equal则end+1

 

思路:hashset可以用,o(n)和o(n)

duplicates可以用hashtable

例题:如果diuplicate的出现次数k,

 

思路:那么判断start的前面有几个,或者判断end-2和end是否一样或者j-i>=2

 

例题:remove element:(inplace)

start是第一个1的位置,然后end是non-1,然后swap,然后i+1,j都要加1,

所以一开始的start是先找到对应1(要先for),也可以不用

for(int i,j;i<len&j<len;j+1){ if (nums[i]!=1) start+=1}

 

例题:  maximum average subarray.

start 是maxim的start。  end++,一个global max,然后更新start。end往前数,然后maximum可以减去头+尾。单个for就可以

思路:也可以累加,然后减去前面k的元素当前的和,然后就是当前的k个和

例题:sliding  window 3

 

思路:rolling hash,利用hashcode计算,而且可以偷懒,类似于上面的去头加尾

 

 

例题:subarrayproduct less than k

start和end,end先移动到最小不满足,然后startmove到满足,这其中每一个sub都是满足的

但是计算的是number,而不是每一个subarray,所以j-i+1是多的validwindow,计算

 

例题: sliding window 2:

 

例题:minimum size subarray sum

 

思路:start,end中间的和,global存储当前的最短,if sum>k,则start+1. 然后继续end+1判断。  start<end肯定

for内嵌while (i),但是i和j相对独立,所以时间复杂度是O(n)

 

例题:sliding window IV

 

例题:longest substring without repeating characters

 

 

区分subsequence和esubarray

遇到duplicate,repeateing,exist,unique都可以用hashmap来解决

 

[展开全文]
shaning · 01-06 · 0

例题:47 permutation 2:

input 有重复,有一个i-1的non-visited判断

 

例题:131,palindrome  partition,实际上是个组合问题,可以用组合模板,先判断前面的substring的是不是palidrome,然后对于后面的substring进行dfs。

优化:dp的memorization将已经pali的存起来

 

例题:44  .1h

 

  • Trie字典树

add and search words

复杂度:O(M)就是最长单词长度,space复杂度:字母表长度*key——length(比如说一个char)*key个数

例题:add and search words

要在对应word的结尾标记一个证明是一个word。

trie是用hashmap实现的

 

例题:auto-complete system: 

 

例题:word search 2.   212.因为input是字符串,所以可以用trie来节省一部分时间,

 

回溯的时候要标记回来,visited.true. dfs(),

visited=false

 

 

trie:

class TrieNode{TrieNode[] next= new TriNode[26],   String word},要标记当前是不是一个word,这就是flag,可以灵活变通,也可以把当前的词存进去

 

 

[展开全文]
shaning · 01-05 · 0

notability

例题329.1h17min

 

 

valid  括号问题 例题

背包问题

例题:301

 

DFS,去重复剪纸

BFS?

 

经典:number of island

 

例题:827

making a large island

复杂度:n2,当前点

例题:312

 

例题:  子问题互相影响,dp[i][k-1]

dp[k+1][j],定义是两边不能炸

 

[展开全文]
shaning · 01-04 · 0
  • DFS&BFS

tree上边的tranversla和divi&&conquer就是DFS

 

 

BFS,binarty tree level-order tranversal一层一层的走就是

图和tree: tree,没有cyce,dfs不会重复,图可能有环,可能死循环如果不记录的话

 

 

where you can search:tree,graph,Combination of Linear structures(array,string, number)

 

LTC 102: binary tree level order Traversal

.BFS用到了queue,FIFO 

stack可以实现DFS,不过先right child然后leftchild,这样可以保证print先left在右,因为stack的先入后出

BFS有模板

 

1h27  例题: 200 number_of island,可以使用DFS,或者queue的BFS

 

1h40  例题:78subsets。  sort,避免重复的number。

使用递归实现combination,复杂度exponential

  • combinatoin

 

所有combination的题目有一个模板2h06

先sort!!!

result。add中 new arraylist(subset)?deep copy

startindex看看是否可以服用,可以复用,i不变否则i+1

例题:90subset2.  2h09, 加上一句判断现在和前者是否一样,并且不能越界。

这样就不用单独新建一个vecotr去重了

 

例题:39  combination sum 

40Com sum2.  右duplicate

216  com sum3.  size=k的sum=target

 

helper必须传的参数,startindex,原始array,每层的solution,总的result

 

 

  • 排列,有顺序有模板

46.permutation。2h31min

所有的数都要被选

permutation 2例题,

 

 

 

[展开全文]
shaning · 01-02 · 0
  • DP 问题

算法原理:

  1. 可以表示成离散状态的相并列和矩阵形式,每个元素代表子问题最优解。子问题不依赖更大的子问题
  2. 最终最优解是多个子问题的最优解来确定(多个状态同时),如果一个状态就是greedy
  3. index最小的子问题解已知
  4. 状态转移方程
  5. 两个方向:“top-down”来分析问题然后bottom-up来优化问题/
  6. top-down一般用递归来解决,bottome-up一般是iteration来解决

算法复杂度:

  1. time complexity:某些子问题解应用不止一次,所以memorizaition来节省空间
  2. space complexity:“某些解只用几次,因此不必在存储”

例题:longest in creaseing subsquence 

 

greedy,使用的话要证明一下多个状态可以用一个状态解释

 

例题:  wiggle subsqueece

 

例题:背包问题

 

例题:96  unique binary search tree

numtrees(n-2)*num(1)+.... numtree(1)*nums(n-2), 左右子树排列数,因为bst型确定了,数也就确定了

 

例题:括号问题,和上面类似

 

 

例题:edit 。。。。  状态转移方程。 1h23 min

例题: pattern  matching  :44  wildcard mathcing

 

 

例题:permutations for di sequence

[展开全文]
shaning · 12-17 · 0
  • 贪心算法和DP

贪心算法:

定义:选择的贪心策略必须具有无后效应,寄某个状态之前的过程不会影响以后的状态,只与当前状态有关。

需要判断一下当前的最优解是不是最终的最优解。

 

最优子结构:当问题的最优解包含子问题的最优解的时候

 

局限性:

  1. 不能保证最后的结果一定是最佳的。
  2. 不能有来求最大或最小解问题
  3. 只能求满足某些约束条件的可行解的范围

上节课的dikistra,prim,krukal算法都是贪心算法。

上述算法也都有一些限制条件,就是为了约束最后的最优解的

 

大部分例题都能有DP解

例题:455: assign cookies。40min

 小给小,大给大,可以sort后双指针遍历人和饼干,

122:Best time to but and Sell stockII

53:

134:gas

55: jump game。 只是求哪里开始可以完成目的可以贪心,但是求最小步骤不能用贪心算法。

 

总结:贪心算法主要是针对一维问题,不需要独立,DP是前后有关系,需要记录

 

 

  • 动态规划

讲一个问题拆分成几个子问题,分别求解子问题。

步骤:

  1. 划分阶段,有序或者可排序(无后序性)
  2. 选择状态(无后行)
  3. 确定状态转移方程(根据上一阶段状态到处本阶段方程),确定了决策,状态转移方程也就出来了
  4. 写出规划方程,只需要写iterative的,不要写recursive。

 

重点:初始状态,和状态转移方程。

基本要素:

  1. 重叠子问题:用到之前很多数的结果,比如fibncci。
  2. 最优子结构
  3. 无后效性,保证之前的状态都已经更新完了才能拿来用,不能够用完这个数据后这个数据还在更新。 循环的顺序和倒序等等。

 

要学会问题归类:尤其是DP问题。例如二维DP,写两层循环。。

一般是最大利润或者最小误差等

例题:198:house robber。

初始条件:最大财务=0.

状态转移方程:每次到房子的时候利用和前面房子的关系,限制条件:不能连续抢。一般来说最后求最大财务数,每一步也要求最大财务书。

对每个房子状态两个:抢或者不抢,强的话:i-2的财务+当前财务。 不强的话:i-1的财务。

一般不用矩阵,因为只跟前一个或两个有关系。直接用几个变量表示就行。 矩阵的话一般是跟前n个有关。

 

 

  • 卖股票系列:

状态转移,当前状态买,卖,不做。

初始值:一般来说是最大利润,

然后加上边界调节。有可能要加矩阵的维度,eg.cooldown

例题集合:1h24min

121.。。。。。。

 

 

贪心算法和动态规划的关系:

相同点

  1. 都是一种递推算法
  2. 均有局部最优解来推导全局最优解

 

不同点:

  • 贪心算法(了解即可,自己做的时候看懂就好)因为要证明最优解还需要时间而且可能会错

每一步的贪心决策都无法改变,之前的最优解不做保留,每一步的最优解一定包括上一步的最优解

 

  • 动态规划

(只要掌握动态规划就好,)

 

 

  • 区间调度问题

最多区间调度问题,可以通过贪心算法1h48min

最大区间:只能用DP

 

例题:56 merge intervals. 2h07min

435

452

252

715 Hard

 

背包问题(leetcode 一般只有01背包和完全背包问题)。

2h17min,记得V的循环顺序

 

lintcode有很多例题

 

 

[展开全文]
shaning · 11-13 · 0

例题:25min

 insert Delete GetRandom.  类似API的设计

getRondom的话可以用math.random的方法。

hashmap,+array_list. 

但还有问题,重复加入怎么办,可以用val:list<indexs>

通常design的题要用更多的data structure去实现

 

例题 :Longest Duplicate substring.47min

我的一点想法:既然重复,那么可以直接双pointer,看字母是否重复,有重复的话,计算substring长度,然后两个起点开始substring check就可以。但是abacabac的话不太实用。

hahsset的用较大一点的质数

nlogn算法。 比如说(0,5)(1,6),(2,7)这些遍历,如果没有就说明siez太大,然后检测size/2,检查(0,2)(1,3),。。。如果有的话,检查上稍大一点,(0,3),(1,4).。

 

 

hashmap和hashset的区别,有collision?

 

 

  • Treemap

 

Treemap红黑树,可以让key按照顺序排列,hahsmap不行 。用的是BST

C++有么????map好像就是。Hashmap的好像是unorder_map的实现

 

complete tree: 所有层数除了最后装满,最后层数尽可能向左靠。(底层实现heap的一个用法)

 

 

例题:longest continuous subarray with absolute diff less than or equal to limit

 

brute force:for for确定subarray,内部还得两两对比,或者最大值或者最小值

优化:slidingwindow+treemap找最值(logn)如果>limit,移动左窗口,并且treemap.remove(num[left])

而且treemap{val:{indexs可能重复}},index要去掉最前面的,不存index的话找不到谁最先。比如remove 2:[2,3,5],要是i=2的会把3和5的去掉,这样就导致后面的误判。

也可以用stack或者queue去优化,比如用global的量去存max差别?

 

例题:1h53min Data Stream as Disjoint intervals.

treemap ,找最值,最小的最大数和最小的最大数2h10min. key:value 就是low bound和high  bound,注意相连的合并情况 [1,2]和[4,5]插入3就变成[1,5]。

[展开全文]
shaning · 2023-11-08 · 0
  • HashMap和Hashtable的区别

Map interface.

Allow NULL(key);

unsynchronized.

not ordered。 eg:  2%16=2.  1%16=1,先存进去的数不一定排在前面。

底层都是array

 

  • Hashfunction

选择质数,不然可能有公约数导致hash confliction。 

 

有hash confilct的话:

Separete chaining.可以用链表(linklist)连接起来所有同hash value的node。(主要记忆即可)。优化方向还可以是BST(访问时间logn)

或者Linear probing:当前confict,找到下一个,直到找到空位。 但是可能效率比较低。

Double Hashing: 发现conflict, 用secondary hash、

 

  • rehash,根据load effector。

 

常见题型

  1. sliding window
  2. 利用hash思想去重,赵duplicate,0(1)时间查找
  3. 有关cache的设计题

 

解题思路,一开始没想法先找brute force的复杂度,然后想办法优化。

例题: contain Duplicates. 利用hashmap(num[i],i),然后用一个pointer代表尾部, find有无相同,然后判断index是不是前面k长度以内的。 也可以put value的时候判断之前最近的index是哪个,然后更新掉value,index的pair

也可以排序好,然后用list《node》存储index和value,然后for去判断相邻的==value的index在不在范围内

 

例题48min:longest substring without repeating characters.   

可以用two pointer做法,然后hashmap存Slow和fast中间的字母判重复,然后重复了之后slow直接移动到fast的位置。不用慢慢移动。

 

 

例题:1h2min。 shortest substring contains the all given characters.

brute force。

而且这里hashpmap不能存index,因为"abbbc",s就不能直接跳了,要一点点移动。f是未满足sunstring的时候移动,s是满足的时候移动。

检查hash是否符合的可以用for loop。 也可以用一个global variable match=n; hashmap里面存需要出现的count,出现一次hash里面对应元素-1. 然后match+1.也可以表示是否符合标准,这样就不用for遍历hash了

 

 

例题1h38min: repeated DNA sequences()可以直接把所有10位长度substing存到hash,然后后面判断有没有出现过

还可以用bitmap,A:00,C:01,G:10:,D:11.  hashvalue作为key也可以,substring作为value

 

 

例题:LRU cache:hashmap

linkedlist只能表示加进cache的顺序,但是get(1)不能反映到linklist里面,

queue不行因为移动的不一定是开头和末尾,中间的无法改变。

思路2h17min处:hash存key,node,node是新class

[展开全文]
shaning · 2023-11-07 · 0
  • stack&queue
  • binary tree&binary search tree

stack FILO,先进后出,可以用array implement

queue FIFO,先进先出,可以用linked list implement

Stack:应用:树上的递归DFS改写为iteration

Queue:应用:1.BFS   2. Moving average

 

Moving average. LC 346. Moving Average from Data Stream.   可以用moving window的题目

 

  • 二叉树

单纯的二叉树,一父节点最多两个子节点,没有大小要求。link list也算是一个二叉树。

 

Balanced binary tree:对任一节点来说左右子树的高度差不超过一。

 

二叉搜索树:左边所有节点<=中间<右边所有节点,平均O(logn),看看是不是balanced。

heap不能进行搜索的操作,只能保证插入删除元素时 logn。

 

 

  • 二叉树

二叉树的遍历:可以用recursive

先序,中序,后序遍历。

叶节点的时候return;

preorder先序遍历:中左右

add;  traverse left; traverse right

inorder中序遍历:左中右。

traverse left;    add;    traverse right;

postOrder后序遍历:左右中 

traverse left; traverse right; add;

可以 go through一些树的list

 

  • 遍历法(traversal)vs分治法

遍历法:依次遍历所有节点,遍历中做记录,对节点进行操作。每个结点的最大深度是上一次最大深度和当前深度的最大值,递归时当前深度+1。 可以用全局变量。 而且可能需要另加一个helper function来记录遍历中的cur_深度

 

分治法:先让左右子树去解决同样的问题,然后得到结果后在整合为整棵树的结果.一个结点的最大深度=左右儿子最大深度+1

 

例题:LC104. Maximum depth of binary tree.

 

 

例题:lc110: balanced binary tree。 细节,子树汇报的时候可以不只汇报height,还可以汇报boolean的balanced,或者用height-1来表示unbalance。因为,最下面子树不balance但是root仍有可能会判断为balance。

recursive经常写helper function,因为i可能return的value或者input可能不一样。

 

用stack表示inorder tranversal。without recursion。有个网站写了逻辑。

 

 

例题:LC173Binary search Tree iterator. 1h41min处

Lc98 validate BST。 1h42min。  可以用stack 来iterate tree,因为iprin出来的值一定是从小到大(BST)。

也可以用recursion来判断

BST上面的inorder tanversal一定是从小到大

 

 

LC938 range sum of BST. 可以用DFS和全局变量,recursive implement ation 。 2h00min

 

LC114. faltten binary tree to lined list. 2h4min. 遍历法可以,分治法,从下往上

 

作业:binary tree paths。

 

 

[展开全文]
shaning · 2023-11-06 · 0
  • 图 graph
  • 图的基本概念
  • 分类存储
  • 遍历
  • 最短路径算法
  • 最小生成树
  • 例题讲解(对于面试很复杂,所以题量少,)

 

 

  • 图论
  1. 图的组成。顶点+边

vertex:度degree(与他连接的点的个数之和)入度(所有接入该点的边数之和)和出度(outdegree)

边(edge)

 

  • 图的分类

有向图和无向图。

有权图(每条边具有一定的权重(weight))和无权图(无权重或者权=1)。

有环图(如果遍历图的顶点,某个顶点可以被访问超过一次)和无环图(tree)。 (这是有向图的分类)

连通图(任意两个顶点都是连通)和非连通图(存在两个顶点不连通)和完全图(所有顶点和其他顶点是连通的)

 

  • 图的存储方式

n个顶点的图有一个n*n大小的邻接矩阵

一个无权图中1代表两点联通,0代表不连通

有权图中每个元素代表权重,0代表不相连。

无向图中,邻接矩阵关于对角线相等。

 

稠密图适合邻接矩阵,稀疏图适合邻接链表

 

邻接链表:每一个点存储一个链表指向所有与该店直接相连的点。 (增加或者删除复杂度更小)

有权图中链表中的元素值对应着权重

 

 

  • 图的遍历

操作有+-vertex。

DFS:访问顶点v,依次v未被访问的邻接点出发,深度优先遍历,直至途中和v有路径相同的顶点都被访问。使用stack

若此时仍有顶点未被访问,则重新开始DFS

 

BFS:使用queue。从队列中取出一个节点然后直接将所有未检验子节点push到queue中。

可以用来解决最短路径的问题。但是需要存储的信息量很大。 

对于稀疏图来说,DFS容易陷进去最长的一支分路。

但是每一层数量过多,BFS也容易耗时。

 

总体来说,倾向于dfs,内存小,解决问题更多一点

 

例题:lc133. clone graph。42min处 

 

  • 最短路径算法。
  • dijistra算法

适用于非负权值的单源最短路径,斐波那契堆。

使用BFS。

 

  • bellman-ford算法

无负权回路(一个回路的权值相加为负)的图每对节点之间的单源最短路径,并能检测负圈。

  • floyd算法

权值有负的单源最短路径,但不能有负圈回路

  • SPFA算法

有负权值,且欸有负圈的图的单源最短路径。

 

 

LC743 network delay time 1h53min,直接可以用dikistra

Lc787。bellman-ford或者BFS。kstop可以直接停

 

 

  • 最小生成树。
  • kruskal算法,prim算法

kruskal算法,

 

 

 

 

 

 

[展开全文]
shaning · 2023-11-06 · 0

Lc873.length of longest fibonacci subsequence

 

back_trakcing   and recurrsive

dynamic programming:得到一个递归表达式

 

 

36:29 dp做法

 

作业:Lc1414. find the minimum number of fibonacci numbers whose sum is k

 

 

recursion 在 merging two sorted list里面怎么用。lc21

 

Lc82 removeduplicates from sorted list II  10min.  在53min处用递归,

Lc 658 Find K closet elements.可以一用heapsort,,

 

Lc 347 top K frequent element;

 

  • quick select

 

Lc215   kth element in an array  可以用heap。也可以quick select

 

Lc973 k closet points to origin

 

LC56  merge interval  例题讲解, stack是啥啊,要先sort

Lc1288 remove covered intervals例题1:30min

lc252 meeting room 1h40min处例题

 

[展开全文]
shaning · 2023-11-04 · 0
  • binary search 

在一个已经排好序的数组上,O(logn )复杂度

先找mid=start+end。 array[mid]=val1,然后判断target,val1<target,就向右找,小于则向左找。重复上述过程, mid2=(end+mid)/2只取整数。

 

写一些函数的时候,先判断input是不是null或length==0?

某些情况下比如while(start+1<end)的话要单独判断end和start是不是target

为什么不是start<end退出,比如下面的例子,找最后一个出现的位置。【2,2】

while(start<end){

   mid=(0+1)/2=0;

if (mid==target){  start =mid;}

}

应该用相邻或相等退出,即start+1<end;

求最后出现的位置: if找到了就向右找,

而且也要先判断end==target

第一个出现的位置,if找到了就向左找。

而且要先判断start==target。

 

而且mid= start+(end-start)/2 更不容易overflow,算是一个小的优化

 

模板:

while (start+1< end){

          mid=start+(end-start)/2;

         if(num[mid]==target)  {return mid}

         else if(  >){  end=mid}

         else{   start=mid }

        if start==target 

       if end==target.

}

 

 

推荐写一些子 函数维持宏观框架

 

 

例题: find K closet elements

思路: 可以先bSearch找到target,然后双指针两边走

先看输出类型,新建好。

然后先写出思路, 然后把子程序的接口写出来,定义出来,input和output,然后写出来子函数的作用:output是什么

 

 

  • Heap

大顶堆和小顶堆,min-heap和max-heap。

每一个node满足:father>=childs (max)

                           father<=childs(min)

左右没有关系

 

binary heap representation:

  现在node为A【i】,

Arr[(i-1)/2] is the parent node.

Arr[2i+1] is the left child

Arr[2i+2] is the right child

 

复杂度:getMini() :对于Min-heap是一个O(1)

extractMin(): remove the root ,O(logn)

insert(): O(logn)

delete(): O(logn)

 

 

  • 重点!!!!!
  • top K的题右3solution
  1. sort O(nlogn) 不是很好
  2. quick select. (on avarge O(n)),有时候快有时候慢。要求是要进行该方法,必须已经拿到全部的数据,万一新来的data,只能重新来一遍
  3. Heap O(nlogk),只需要size 为k的heap, insert 每一次都是logk,然后比n次,现实生活中k远小于n。更适合Stream data,可以适用于新来的data,新来一个数是O(logk

例题:Kth largest element要用min-heap,因为和root比较,小的就不用insert,大的菜肴insert进去,因为,heap里面村的是k个最大的,

步骤:先建立一个k size的heap,直接加进去,然后对比,如果大于,则pop root之后push(元素 )

[展开全文]
shaning · 2023-10-28 · 0