- 在线时间
- 1630 小时
- 最后登录
- 2024-1-29
- 注册时间
- 2017-5-16
- 听众数
- 82
- 收听数
- 1
- 能力
- 120 分
- 体力
- 564647 点
- 威望
- 12 点
- 阅读权限
- 255
- 积分
- 174617
- 相册
- 1
- 日志
- 0
- 记录
- 0
- 帖子
- 5313
- 主题
- 5273
- 精华
- 3
- 分享
- 0
- 好友
- 163
TA的每日心情 | 开心 2021-8-11 17:59 |
|---|
签到天数: 17 天 [LV.4]偶尔看看III 网络挑战赛参赛者 网络挑战赛参赛者 - 自我介绍
- 本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。
 群组: 2018美赛大象算法课程 群组: 2018美赛护航培训课程 群组: 2019年 数学中国站长建 群组: 2019年数据分析师课程 群组: 2018年大象老师国赛优 |
: D. X! _5 o6 L5 i0 D
算法越学越扎心,有没啥破解之法?$ O C/ x. Q" y2 ~
算法越学越扎心,有没啥破解之法?
. H( K) A3 B; ?9 m$ _
3 f0 b7 D1 G' d0 S0 f# O2 T, T$ b对于算法的学习,我也是从一个小白一步步走来,当然,现在仍然很菜,,,不过,鉴于我觉得还有一些人比我更菜了,我决定谈谈我算法学习过程走过的坑,以及自己总结的一些经验。
9 ~, d* F( B$ u$ [% R* H7 p5 u
- ?) X9 v" O% X3 s9 D切勿盲目刷题:刷题前的知识积累; G4 D5 L' @- m- O
: X+ Q: H% K' Y# V, H9 t. }- R
说实话,想要提高自己的算法,真的没啥捷径,我觉得最好的捷径就是脚踏实地着多动手去刷题,多刷题。$ B, A, O; D2 |: w r* A* _ ]8 ^; l
! l* |6 S& H% x: Q8 J& O
但是,我必须提醒的是,如果你是小白,也就是说,你连常见的数据结构,如链表、树以及常见的算法思想,如递归、枚举、动态规划这些都没学过,那么,我不建议你盲目疯狂着去刷题的。而是先去找本书先去学习这些必要的知识,然后再去刷题。
% s0 ^1 n0 ^" p+ f. }1 V2 j# @. `. v+ E7 C/ ~$ ?* r. r l
因为,如果这些基础都不懂的话,估计一道题做了几个小时,然后看答案都看不懂,做题没有任何思路,这是很难受的。久而久之,估计没啥动力了,我刚开始就是这样,一道题答案看一天,然而还是不大懂,什么回溯啊,暴力啊,还不知道是啥意思。
+ t! V7 C4 g1 z1 Y# r! {4 j, S. F) ^+ j, {
也就是说,假如你要去诸如leetcode这些网站刷题,那么,你要先具备一定的基础,这些基础包括:2 h& `# g* c v. R) l6 y1 F
. e/ s6 I1 G: \; M
1、常见数据结构:链表、树(如二叉树)。(是的,链表和二叉树是重点,图这些可以先放着)& @9 m6 ^: {! J
0 k0 U* s* ?% l6 `, e) p& O2、常见算法思想:贪婪法、分治法、穷举法、动态规划,回溯法。(贪婪、穷举、分治是基础,动态规划有难度,可以先放着)
2 X" t& l9 ~& g; q' @0 m1 g
; m5 O0 O/ p0 z4 p以上列出来的算是最基本的吧。就是说你刷题之前,要把这些过一遍再去刷题。如果你连这些最基本的都不知道的话,那么你再刷题的过程中,会很难受的,思路也会相对比较少。. B" e) Q$ N$ y' b" J
- Q/ \- {& f6 j8 }6 M1 ^总之,千万不要急,先把这些基本的过一遍,力求理解,再去刷题。- M: t* F# e. _, x/ C! U. y
3 e0 m0 g2 t9 T8 E7 }2 ?+ l
在这里,我推荐基本我大一时看过的书籍吧,感觉还是非常不错的,如果对于数据结构时零基础的话,那么我建议你可以看《数据结构与算法分析:C语言描述版》这本书,这本书自认为真的很 nice,当时我把这本书里面的全部都看了,并且 coding 了一遍,感觉整个人有了质的飞跃。4 ^; d: F/ \$ f# r4 C
T/ ^5 \! |; I: K% u) N3 V' u6 C
后面我时在一些学校的OJ刷题,当时看的一本书叫做《挑战程序设计大赛》,日本作家写的,我觉得这本书也很nice,里面有分初级,中级和高级三个模块,基础比较差的可以从初级开始看起。
- j, ]8 \5 K) {$ ]" m
) `& d g% g8 l" f' g3 h! I当然,这两本书,你可以在这个Github上找到:https://github.com/iamshuaidi/CS-Book$ N, e$ H5 W- P3 o& m! K# u* D
总结下:
! R: i$ C, j \" Z5 X; L
4 \/ C4 i) Q: n" H5 V! X提高数据结构与算法没啥捷径,最好的捷径就是多刷题。但是,刷题的前提是你要先学会一些基本的数据结构与算法思想。1 a8 y9 [# S3 E0 i- M& r" X1 d
8 z% J6 e8 h/ t' A7 s- H3 hAC不是目的,我们要追求完美 z" W3 r3 d( a2 Q, M3 D/ J
% W. C5 T% {, h0 _如何刷题?如何对待一道算法题? B9 U& V- k: v+ T7 ~
5 L& l. G) c$ S e+ d3 ~我觉得,在做题的时候,一定要追求完美,千万不要把一道题做出来之后,提交通过,然后就赶紧下一道。我认为这意义不大,因为一道题的解法太多了,有些解法态粗糙了,我们应该要寻找最优的方法。- ^ B- @5 W! }8 H! B7 `6 p
3 @, |; {$ {& N/ ?1 t
算法能力的提升和做题的数量是有一定的关系,但并不是线性关系。也就是说,在做题的时候,要力求一题多解,如果自己实在想不出来其他办法了,可以去看看别人是怎么做的,千万不要觉得模仿别人的做法是件丢人的事。) X- |7 b7 i: A9 y1 f% E2 a
) z1 l5 f& }, Y7 Y
我做题的时候,我一看到一道题,可能第一想法就是用很粗糙的方式做,因为很多题采用暴力法都会很容易做,就是时间复杂度很高。之后,我就会慢慢思考,看看有没其他方法来降低时间复杂度或空间复杂度。最后,我会去看一下别人的做法,当然,并不是每道题都会这样执行。( L- B; W' ~3 R: h8 H# i) {
, O4 K$ x$ i1 D- F8 h2 v
衡量一道算法题的好坏无非就是时间复杂度和空间复杂度,所以我们要力求完美,就要把这两个降到最低,令他们相辅相成。
, Y# ?8 G( i6 w0 z, E) V
+ x( L$ x! I6 I) ]8 D我举道例题吧:
$ H9 e" B) k. D$ G8 `3 }
) M0 D5 U5 i" j' }5 a问题: 一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法?
! ]) S1 Q4 \5 R1 Y0 ?
+ Q7 [9 y8 h* e- H; E% y5 J; J这道题我在以前的分章分析过,不懂的可以先看下之前写的:递归与动态规划—基础篇1" M" s3 L- k5 [1 ?9 B
m4 v5 Y- E8 g$ \# k" ?3 d/ Z方法1::暴力递归8 z2 Y6 a( w y# @- s! G8 Y4 `$ J
& L* i" |/ B7 s$ V; m0 U7 `7 p, |% M这道题不难,或许你会采取下面的做法:
) e5 Y1 i. M2 e, l# B* H9 M
" o# k5 P5 o' U+ |- o. q9 s: F( i7 b8 ppublic int solve(int n){0 w" O# t) S1 L2 S* ^9 |8 P
if(n <= 2){
" X, \; p6 [# y return n;' E A$ ^5 _3 x+ Z3 A. u
}else{; G9 @. o1 Y% l- K# k. n
return solve(n-1) + solve(n-2);3 t- y U7 e* O! c, P
} p% ?7 w9 f; }2 W0 o, P% ?+ G
}
# X+ C4 D$ n0 j; G, ]6 `5 i: D, x1$ e4 |( |1 T, i C) c5 e9 W0 i/ ]" k& @
2" l' f' j$ d# F5 c# f- Z/ n# |% v
3
( `$ J! n& i% \, w* e4
( P. M! A( d8 ]. K4 D5
3 r0 ]' `+ b3 Z/ i6 ?9 c6) g) x; h, d, d& T
7, [9 h1 q3 D% Y! \( J( I( {- ]# E, B
这种做法的时间复杂度很高,指数级别了。但是如果你提交之后侥幸通过了,然后你就接着下一道题了,那么你就要好好想想了。- T0 o/ b7 ?7 n; w
& [0 j0 \. r1 U9 x" l1 i方法二:空间换时间3 s& r) Z* \9 s6 Y" H: I( ?7 H
+ @+ e' N5 r! c% f力求完美,我们可以考虑用空间换时间:这道题如何你去仔细想一想,会发现有很多是重复执行了。不行你可以画个图
9 w- x: C2 V C$ ?4 K" l
% A; X) ~$ y m$ o/ `1 |) e所以可以采取下面的方法:
4 L5 H6 {: D" X' J
8 N. e* ^+ v' O5 t//用一个HashMap来保存已经计算过的状态, [2 h+ m! o( W, [$ L
static Map<Integer,Integer> map = new HashMap();; _7 V; w k$ {2 @) s/ w1 m
public static int solve(int n){
# m( s! ]. d3 r% V1 e if(n <= 2){& S9 s6 _7 R: D
return n;
) N% Q# a/ H1 F# K0 Z- D }else{//是否计算过
3 F; X9 t3 F6 I* {+ D if(map.containsKey(n)){
6 r: X9 H$ c" }! y6 B4 M return map.get(n);& L8 A4 @' G) T- P- `4 U* ?/ M
}else{
) l/ q' k! I& p, f/ Q int m = solve(n-1) + solve(n-2);
" v- V& m' b7 M3 p map.put(n, m); s4 Q" g Q" E% c
return m;
7 ]5 C# n7 C: v0 \& F }2 R1 d4 U2 h9 o% [; k
}$ f& ~: ^. A3 g. c! O
}
& Z( H5 U0 ^0 J
/ N- c. U8 }1 F g$ X# h1
: h* A0 [+ I2 C7 Q% A* Z2" |% B# A9 g! g% h I+ J
3
2 X' P' o# M5 P3 `; r4 B3 U7 g4
r; h/ q! K' G8 k) X; D5
1 E4 g7 X5 f1 k* G1 k% f5 S67 Y2 r# @1 ~( a ]' q1 |* M
7
P/ O9 w3 L( k3 ^# x. T" S1 c82 k3 n) b9 Y# _5 r+ {
95 g7 d1 c% U5 X3 B+ ^
10, K9 D- g9 l6 e+ y8 I& T1 V
112 t7 f- e% y8 i! R) Z. J6 R G6 q
12
2 A+ _* T' G( f3 v9 |" z" C% d13: E p- a. n" F0 g
14
$ I, v1 b# P) E4 }15 b$ k) q' Y0 X9 l3 R
16
" W4 Q4 r) a: Z3 s1 W$ T; S1 I这样,可以大大缩短时间。也就是说,当一道题你做了之后,发现时间复杂度很高,那么可以考虑下,是否有更好的方法,是否可以用空间换时间。
$ f4 N# _) A- Q7 Q
% z3 U+ H9 X5 j+ e7 u方法三:斐波那契数列
6 [ j) o* m0 K6 p
: }+ a9 k1 ?4 ^& {9 e2 h- C6 t4 _实际上,我们可以把空间复杂度弄的更小,不需要HashMap来保存状态:! R; Q, r0 k; m( ?* \1 F
8 ]& _3 f, f% M \( spublic static int solve(int n){1 R& Z4 _0 L' l& k' y8 Y
if(n <= 2){9 a0 P8 o8 G) M# l4 v& l* d* Q
return n;
; y& I' ]* N5 T, X/ E }
. c3 {+ Y- X& s# O& A int f1 = 0;
: T6 n# w9 Y6 @. w0 O int f2 = 1;* ?. ] K- O2 K
int sum = 0;
: V# [) _4 z% }# k; x' g for(int i = 1; i<= n; i++){* h% C) g- z- i' X% b; G
sum = f1 + f2;+ A6 U( T% u( I+ |
f1 = f2;
: s }$ M8 w3 O; ]% c f2 = sum;
4 C9 \% l5 q9 }% l }
6 a2 I9 |4 @3 g+ U return sum;
- [; _6 w4 \; P& J2 E! z' x}' `/ D0 O/ h/ ?! J; B1 i* S1 p. y
16 v5 R) } a. {0 ?& `; O( m
2
7 o3 z3 c- Z$ {! U( T3, ^+ f& `! n2 [- D: t' N
4; H$ @9 A/ y. r* l2 A
56 P! m' q: R, x
6
- Q' d" T* a" Y7
; E$ v" U4 l/ \, f0 o! _8
; C& K+ t; ~. x( l/ c6 \9
$ w( `2 y2 m/ u7 u, A2 ^# a10. W2 G! x- @9 i7 j
115 N; \8 f: V% u6 Q S
129 u _" V9 x5 G* m/ E
13
- G& v F( R0 |- ~$ F14
* O" T, d* M2 |4 M# \) A& d) s我弄这道题给你们看,并不是在教你们这道题怎么做,而是有以下目的:' e' s( }( U2 N2 k/ W) b7 t
9 z7 Y- ~/ ]' \1、在刷题的时候,我们要力求完美。
+ u3 }8 N Z; Z2 S& X
/ w" q; Q/ z7 D8 u& t- R2、我想不到这些方法啊,怎么办?那么你就可以去看别人的做法,之后,遇到类似的题,你就会更有思路,更知道往哪个方向想。. r3 H# h* j5 o1 B
2 A7 l! \+ b3 n( ~( n( g3、可以从简单暴力入手做一道题,在考虑空间与时间之间的衡量,一点点去优化。5 N" n/ d* Q% N3 w
3 h5 A! A l+ t挑战自己,跳出舒适区. [0 v( U" m( ~% C! R" j6 L9 T# F
5 A1 G# }3 C. p; G. b' D3 F什么叫舒适区?在刷题的时候,可能有一类题是你比较懂的,你每次一看就有思路,然后半个小时就撸好代码,提交代码,然后通过了,然后,哇,又多刷了一道题,心里很舒服。9 ^8 p; ~! |1 ~ Y! T, h5 G$ x }
A+ _4 g2 W3 \; y: _ c- ?& H
但是,记住,前期你可以多刷这种题练手,提升自己的乐趣,但,我还是建议你慢慢跳出舒适区,去做一些自己不擅长的题,并且找段时间一直刷这种题。例如,我觉得我在递归方面的题还是挺强的,% |* S6 s2 [9 Y6 G
但是,我对动态规划的题,很菜,每次都要想好久,每次遇到这种题都有点害怕,没什么信心。不过有段时间我觉得只刷动态规划的题,直接在 leetcode 选定专题,连续做了四五十道,刚开始很难受,后来就慢慢知道了套路了,一道题从两三个小时最后缩到半小时,简单的十几分钟就搞定。感觉自己对这类型的题也不惧怕的。
4 |8 n4 m2 y& Q+ q" u' N8 g2 B) | c! r d7 o
当然,对于动态规划的学习,大家也可以看我这篇广受好评的文章:为什么你学不过动态规划?告别动态规划,谈谈我的经验
8 w5 E" x$ X3 Q: i/ h$ y; C: y
* K2 k. `3 o' }( d4 N% J: R9 q所以,建议你,一定要学好跳出自己的舒适区。# \% Z4 }8 L: C) `. x( D
# d7 C4 O7 V# @9 k4 c
一定要学会分类总结- g: X! h/ ^0 D7 [
% w( |+ I& ?2 E有些人以为 leetcode 的题刷的越多,就一定能越厉害,其实不然,leetcode 虽然有 1000 多道题,但题型就那么几类,我们前期在刷的时候,我是建议按照题型分类刷题的,例如我这整理刷二叉树相关,然后刷链表相关,然后二分法,然后递归等等,每刷一种题型,都要研究他们的套路,如果你愿意去总结,那么 leetcode 的题,其实你刷几百道,有目的、挑选的刷,我觉得就差不多了。$ [% p' f# G% W) d/ w# a. J
$ ~$ T( t3 f3 y
我看过一本书,叫做《程序员代码面试指南:IT 名企算法与数据结构题目最优解》,这本书就非常不错,里面按照栈,队列,链表,二叉树,字符串等一个专题一个专题来刷的,并且每道题都给出了最优解,而且里面的题有一定的难度,感兴趣的,真心不错,如果你把这本书的题全部搞定,并且总结相关套路,那么你的算法一定有很大的提升。( d( L U; ~: \* g: V
+ d, x- l8 E7 T) D推荐一些刷题网站
/ u+ H5 C3 L* g9 N: v
4 l* \- T+ k7 W0 c" ]+ N& J, D+ T我一般是在leetcode和牛客网刷题,感觉挺不错,题目难度不是很大。0 j9 L0 [1 e, j/ _% D! [
0 o b, h. w) W' S6 n在牛客网那里,我主要刷剑指Offer,不过那里也有个在线刷leetcode,不过里面的题量比较少。牛客网刷题有个非常方便的地方就是有个讨论区,那里会有很多大佬分享他们的解题方法,不用我们去百度找题解。所以你做完后,实在想不出,可以很方便着去看别人是怎么做的。
6 ~* ]- `. e/ H' ~, {5 \8 |" E, ]7 f# [! a
至于leetcode,也是大部分题目官方都有给出答案,也是个不错的刷题网站。你们可以两个挑选一个,或者两个都刷。
) ^6 k# J6 Y( p& h, s2 x' z3 @+ _! W! v8 Z6 D& k) X! W
当然,还有其他刷题的网站,不过,其他网站没刷过,不大清除如何。6 a9 C+ O4 m! n7 T" C
" u3 k* s, D( E7 W8 @5 ?至于leetcode,有中文版和英文版
! S4 d/ D) U4 @$ a% z; O( Z7 B/ o& [+ }
leetcode有中文版1 W2 T; [- _: \8 Q9 n, [
: n5 x% Q# w8 P0 T) H英文版
+ E: M+ O* o5 |! R
7 R0 }5 \) W! h& q% A2 O根据自己的兴趣选。; H, `: {6 _3 m4 E# M7 L
: d" j: D: {' z. |
学习一些解题技巧' z& ?- V0 p# [0 C9 X5 R& J
$ o( {" _" D# ]5 d# M说实话,有些题在你没看别人的解法前,你好不知道有这么美妙优雅的解法,看了之后,卧槽,居然还可以这样。而我们在刷题的过程中,就要不断累积这些技巧,当你累计多了,你就会形成一种
. I7 w8 c7 S# Z神经反应,一下子就想到了某种方法。解题技巧很多,例如数组下标法、位图法、双指针等等,我自己也分享过一篇总结一些算法技巧的文章1 i0 M: Y" o# `, d, o3 F- |
0 _: }; |6 ~8 J% l$ @7 h+ v推荐阅读:一些常用的算法技巧总结
/ X3 a7 S3 E% e3 Z
4 g/ G4 ^2 N3 R# ^1 t例如在刷题的时候,我们要学会巧用双指针、数组下标法、位运算等等技巧来解决问题,可能会有意想不到的效果。我给你再找点我之前写文章的一些例子吧:
3 A% l M- Z: n5 b3 Q
' D; ?, s1 M) g, g% S分享一道解法巧妙的算法题
4 y- i; o$ E8 A j2 g( |; A9 i3 P7 h8 z3 {$ a
【算法技巧】位运算装逼指南
3 g3 q$ W- v# m: F0 ^4 c0 S' a C) }: {
这是个长期累积的过程,我自己也精彩在我的公众号里分享一些解题的文章,感兴趣的可以关注我的公众号:帅地玩编程。1 P3 Z* b; m \8 U* s$ O3 f! W
4 s4 a% T, [, a/ Q+ E7 y
再说数据结构发重要性9 R6 b! D( ^ w2 Z
v; Y1 c0 O6 u D! D6 P' X
前面我主要是说了我平时都是怎么学习算法的。在数据结构方法,我只是列举了你们一定要学习链表和树(二叉堆),但这是最基本的,刷题之前要掌握的,对于数据结构,我列举下一些比较重要的:
' h: S0 D, S6 S1 h" C: n0 H
6 M) V* `+ o3 b7 F1、链表(如单向链表、双向链表)。
) {! Z; s6 I F% G/ h. h: R/ U' j2 w% I, a/ j, x7 A: p
2、树(如二叉树、平衡树、红黑树)。+ ]( T; t' a; b/ e( o$ _' [- G
: A0 H Q* U2 \3、图(如最短路径的几种算法)。' |, i; T9 l) ]8 I. w6 s
& s5 `& [& v+ h4 G7 p9 l0 o4、队列、栈、矩阵。
; }0 q2 y' q. f# D5 n9 l: |$ B; D+ t" G$ Y* N
对于这些,自己一定要动手实现一遍。你可以看书,也可以看视频,新手可以先看视频,不过前期可以看视频,之后我建议是一定要看书。& o) |9 e0 h9 H: t4 |4 f1 S
|/ U5 q6 e+ R% L; F5 L例如对于平衡树,可能你跟着书本的代码实现之后,过阵子你就忘记,不过这不要紧,虽然你忘记了,但是如果你之前用代码实现过,理解过,那么当你再次看到的时候,会很快就记起来,很快就知道思路,而且你的抽象能力等等会在不知不觉中提升起来。之后再学习红黑树啊,什么数据结构啊,都会学的很快。
/ l- y i3 r: K
4 F- x+ s3 E a* e: P5 y0 u% t% X- w对于有哪些值得学习的算法,我之前也总结过,这里推荐给大家程序员必须掌握的核心算法有哪些?,这篇文章居然 40多万阅读量了,有点受宠若惊。
; ?; P3 }0 \, ^; d/ @) L# L/ u) q7 x0 U
最最重要
, L; G) G4 }5 @( F7 O; c+ k& \5 t# Q8 O
动手去做,动手去做,动手去做。重要的话说三遍。, D: U$ w1 v$ w
/ X* i' V) u( r# F# Z$ I
千万不要找了一堆资源,订好了学习计划,我要留到某某天就来去做…. j. d' ~) ?. w+ E1 @
3 L" B! j# t7 @ H, `千万不要这样,而是当你激情来的时候,就马上去干,千万不要留到某个放假日啊什么鬼了,很多这种想法的人,最后会啥也没做的。" b0 L! X! f8 U3 s
' [5 {5 p% F+ O3 l6 |9 F. I
也不要觉得要学习的有好多啊,不知道从哪学习起。我上面说了,可以先学习最基本的,然后刷题,刷题是一个需要长期坚持的事情,一年,两年。在刷题的过程中,可以穿插和学习其他数据结构。
1 r6 `/ @9 D8 s" r5 p0 U
9 e9 A8 \+ X! @6 G+ u, ?总结一下吧8 x: W5 X/ }9 ` s& J1 m4 u, d2 u( Y
1 S7 o7 x0 x6 L. [/ L: z. \/ e所以我给大家的建议就是,先学习基本的数据结构以及算法思想,不要盲目刷题,接着刷题的过程中,不能得过且过,尽量追求最优解,还有就是要跳出舒适区,逼自己成长,刷题的过程中,要学会分类总结。
* O, \5 l# X$ a& n( U: J
5 r8 M* P. z9 e4 |3 P& I当然,最重要的,就是你去动手了,不然,一切免谈!, }/ u8 @6 V4 E
- V9 o7 F/ t6 _看在熬夜写过的份上,送我个赞呗,嘻嘻。7 Y# z: ^% o3 o- _
————————————————
4 y& B) [9 r, i1 t$ q4 b5 f版权声明:本文为CSDN博主「帅地」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
$ Z, u. k; L* x$ o* f3 k, ]原文链接:https://blog.csdn.net/m0_37907797/article/details/104765116$ Z2 J; D; V8 \3 c$ A4 j: ]* b4 ]
% L( {6 `' ~; K
: Q, b! S; F8 c: E5 N |
zan
|