Leetcode CPP
Uploaded by
Kevin LiangLeetcode CPP
Uploaded by
Kevin LiangLeetCode
(soulmachine@gmail.com)
https://github.com/soulmachine/leetcode
2016-1-28
Creative Commons
3.0 Unported
?iiT,ff+`2 iBp2+QKKQMbXQ`;fHB+2Mb2bf#v@M+@b fjXyf
(cc by-nc-sa)
ACM
LeetCode Online Judge(http://leetcode.com/onlinejudge)
C++ 11
LeetCode Online Judge
:
OJ
.h
Shorter is better
.cpp
STL
malloc()/new
nullptr
C++
GitHub
GitHub
https://github.com/soulmachine/leetcode
http://q.weibo.com/1312378
http://book.douban.com/subject/2024655/
Algorithms
Robert Sedgewick, Addison-Wesley Professional, http://book.douban.com/subject/4854123/
Java
2.1
. . . . . . . . . . . . . . .
2.1.1
Remove
Duplicates
from Sorted Array . . .
2.1.2
Remove
Search
in
Search
in
2.1.5
Longest
Consecutive
8
2.1.7
Two Sum . . . . . . . .
10
2.1.8
3Sum . . . . . . . . . . 12
2.1.9
3Sum Closest . . . . . .
35
2.1.22 Candy . . . . . . . . . .
36
2.1.23 Single Number . . . . .
37
2.1.24 Single Number II . . . .
38
. . . . . . . . . . . . .
40
2.2.1
Add Two Numbers . . .
40
2.2.2
Reverse Linked List II .
41
2.2.3
Partition List . . . . . .
42
2.2.4
Remove
2.2.5
Sequence . . . . . . . .
2.1.21 Gas Station . . . . . . .
Duplicates
from Sorted List . . . .
Median of Two Sorted
Arrays . . . . . . . . . .
2.1.6
Rotated
Sorted Array II . . . . .
33
2.2
Rotated
Sorted Array . . . . . .
2.1.4
Duplicates
from Sorted Array II . .
2.1.3
2.1.20 Set Matrix Zeroes . . . .
13
Remove
43
Duplicates
from Sorted List II . . .
44
2.2.6
Rotate List . . . . . . .
46
2.2.7
Remove
Nth
Node
From End of List . . . .
47
2.2.8
Swap Nodes in Pairs . .
47
2.2.9
Reverse Nodes in k-Group 49
2.2.10 Copy List with Random
2.1.10 4Sum . . . . . . . . . . 14
2.1.11 Remove Element . . . . 18
2.1.12 Next Permutation . . . . 19
2.1.13 Permutation Sequence . 21
Pointer . . . . . . . . .
50
2.2.11 Linked List Cycle . . . .
51
2.2.12 Linked List Cycle II . .
52
2.2.13 Reorder List . . . . . .
53
2.2.14 LRU Cache . . . . . . .
55
2.1.14 Valid Sudoku . . . . . .
23
2.1.15 Trapping Rain Water . .
24
2.1.16 Rotate Image . . . . . .
27
2.1.17 Plus One . . . . . . . .
28
3.1
Valid Palindrome . . . . . . . .
57
2.1.18 Climbing Stairs . . . . . 30
3.2
Implement strStr() . . . . . . . .
58
2.1.19 Gray Code . . . . . . .
3.3
String to Integer (atoi) . . . . .
60
31
ii
57
iii
3.4
Add Binary . . . . . . . . . . .
61
3.5
Longest Palindromic Substring . 62
3.6
Regular Expression Matching . .
66
3.7
Wildcard Matching . . . . . . .
67
3.8
Longest Common Prefix . . . . 69
3.9
Valid Number . . . . . . . . . . 70
5.1.5
Binary Tree Level Order Traversal II . . . . .
5.1.6
Binary
Tree
Zigzag
Level Order Traversal .
5.1.7
94
96
Recover Binary Search
Tree . . . . . . . . . . .
98
99
3.10 Integer to Roman . . . . . . . .
72
5.1.8
Same Tree . . . . . . .
3.11 Roman to Integer . . . . . . . .
73
5.1.9
Symmetric Tree . . . . . 100
3.12 Count and Say . . . . . . . . . . 74
5.1.10 Balanced Binary Tree . . 102
3.13 Anagrams . . . . . . . . . . . .
5.1.11 Flatten Binary Tree to
75
Linked List . . . . . . . 103
3.14 Simplify Path . . . . . . . . . . 76
3.15 Length of Last Word . . . . . .
77
79
4.1
. . . . . . . . . . . . . . . .
5.1.12 Populating Next Right
Pointers in Each Node II 105
5.2
. . . . . . . . . 106
5.2.1
79
Construct Binary Tree
4.1.1
Valid Parentheses . . . . 79
from Preorder and In-
4.1.2
Longest Valid Paren-
order Traversal . . . . . 106
5.2.2
theses . . . . . . . . . . 80
4.1.3
4.1.4
torder Traversal . . . . . 107
82
5.3
Evaluate Reverse Polish Notation . . . . . . .
4.2
from Inorder and Pos-
Largest Rectangle in
Histogram . . . . . . . .
. . . . . . . . . . . 108
5.3.1
84
5.3.2
86
5.1
5.1.2
5.3.4
Convert Sorted Array to
Tree . . . . . . . . . . . 111
86
Binary Search Tree . . . 112
88
5.3.5
Binary Tree Postorder
Traversal . . . . . . . .
5.1.4
Validate Binary Search
Binary Tree Inorder
Traversal . . . . . . . .
5.1.3
5.3.3
Binary Tree Preorder
Traversal . . . . . . . .
Convert Sorted List to
Binary Search Tree . . . 113
90
Binary Tree Level Order Traversal . . . . . .
Unique Binary Search
Trees II . . . . . . . . . 110
. . . . . . . . . 86
5.1.1
Unique Binary Search
Trees . . . . . . . . . . 108
. . . . . . . . . . . . . . . 85
Construct Binary Tree
5.4
. . . . . . . . . 114
5.4.1
92
Minimum Depth of Binary Tree . . . . . . . . 115
iv
5.4.2
Maximum Depth of Bi-
8.3.2
next_permu-
nary Tree . . . . . . . . 116
tation() . . . . . . . . . 142
8.3.3
5.4.3
Path Sum . . . . . . . . 117
5.4.4
Path Sum II . . . . . . . 118
5.4.5
Binary Tree Maximum
8.4.1
Path Sum . . . . . . . . 119
8.4.2
5.4.6
8.4
next_permutation() . . . 144
next_permutation() . . . . . . . . . 144
8.4.3
8.5
Sum Root to Leaf Numbers . . . . . . . . . . . 121
Permutations II . . . . . . . . . 144
Populating Next Right
Pointers in Each Node . 120
5.4.7
. . . . . . . . . . 143
123
8.6
. . . . . . . . . . 144
Combinations . . . . . . . . . . 146
8.5.1
. . . . . . . . . . 146
8.5.2
. . . . . . . . . . 147
Letter Combinations of a Phone
6.1
Merge Sorted Array . . . . . . . 123
Number . . . . . . . . . . . . . 147
6.2
Merge Two Sorted Lists . . . . . 124
8.6.1
. . . . . . . . . . 148
6.3
Merge k Sorted Lists . . . . . . 124
8.6.2
. . . . . . . . . . 149
6.4
Insertion Sort List . . . . . . . . 125
6.5
Sort List . . . . . . . . . . . . . 126
6.6
First Missing Positive . . . . . . 127
6.7
Sort Colors . . . . . . . . . . . 128
131
7.1
Search for a Range . . . . . . . 131
7.2
Search Insert Position . . . . . . 132
7.3
Search a 2D Matrix . . . . . . . 133
8
8.1
8.2
8.3
135
Subsets . . . . . . . . . . . . . 135
150
9.1
Word Ladder . . . . . . . . . . 150
9.2
Word Ladder II . . . . . . . . . 154
9.3
Surrounded Regions . . . . . . . 162
9.4
. . . . . . . . . . . . . . . 164
9.4.1
. . . . . . . . 164
9.4.2
. . . . . . 164
9.4.3
. . . . . . . . 165
10
173
10.1 Palindrome Partitioning . . . . . 173
10.2 Unique Paths . . . . . . . . . . 176
8.1.1
. . . . . . . . . . 135
10.2.1
8.1.2
. . . . . . . . . . 137
10.2.2
. . . . . . . . 176
Subsets II . . . . . . . . . . . . 138
10.2.3
. . . . . . . . . . 177
8.2.1
. . . . . . . . . . 138
10.2.4
. . . . . . . . 178
8.2.2
. . . . . . . . . . 141
. . . . . . . . . . 176
10.3 Unique Paths II . . . . . . . . . 179
Permutations . . . . . . . . . . 142
10.3.1
. . . . . . . . 179
8.3.1
10.3.2
. . . . . . . . . . 180
next_permutation() . . . 142
v
10.4 N-Queens . . . . . . . . . . . . 181
13.4 Maximal Rectangle . . . . . . . 213
10.5 N-Queens II . . . . . . . . . . . 184
13.5 Best Time to Buy and Sell Stock
10.6 Restore IP Addresses . . . . . . 186
III . . . . . . . . . . . . . . . . 214
10.7 Combination Sum . . . . . . . . 188
13.6 Interleaving String . . . . . . . 215
10.8 Combination Sum II . . . . . . 189
13.7 Scramble String . . . . . . . . . 217
10.9 Generate Parentheses . . . . . . 190
13.8 Minimum Path Sum . . . . . . . 222
10.10 Sudoku Solver . . . . . . . . . 192
13.9 Edit Distance . . . . . . . . . . 224
10.11 Word Search . . . . . . . . . . 193
13.10 Decode Ways . . . . . . . . . 226
10.12
. . . . . . . . . . . . . . 195
13.11 Distinct Subsequences . . . . . 227
10.12.1
. . . . . . . 195
13.12 Word Break . . . . . . . . . . 228
10.12.2
. . . . . . 195
13.13 Word Break II . . . . . . . . . 230
10.12.3
. . . . . . . 197
10.12.4
. 197
10.12.5
. . 197
11
199
11.1 Pow(x,n) . . . . . . . . . . . . . 199
11.2 Sqrt(x) . . . . . . . . . . . . . . 200
14
232
14.1 Clone Graph . . . . . . . . . . . 232
15
235
15.1 Reverse Integer . . . . . . . . . 235
15.2 Palindrome Number . . . . . . . 236
15.3 Insert Interval . . . . . . . . . . 237
201
15.4 Merge Intervals . . . . . . . . . 238
12.1 Jump Game . . . . . . . . . . . 201
15.5 Minimum Window Substring . . 239
12.2 Jump Game II . . . . . . . . . . 202
15.6 Multiply Strings . . . . . . . . . 241
12.3 Best Time to Buy and Sell Stock 204
15.7 Substring with Concatenation
12
12.4 Best Time to Buy and Sell Stock II205
of All Words . . . . . . . . . . . 244
15.8 Pascals Triangle . . . . . . . . 245
12.5 Longest Substring Without Repeating Characters . . . . . . . 206
15.9 Pascals Triangle II . . . . . . . 246
12.6 Container With Most Water . . . 207
15.10 Spiral Matrix . . . . . . . . . . 247
13
209
15.12 ZigZag Conversion . . . . . . 250
13.1 Triangle . . . . . . . . . . . . . 209
15.13 Divide Two Integers . . . . . . 251
13.2 Maximum Subarray . . . . . . . 210
15.14 Text Justification . . . . . . . . 253
13.3 Palindrome Partitioning II . . . 212
15.15 Max Points on a Line . . . . . 255
15.11 Spiral Matrix II . . . . . . . . . 248
vi
44#
7 #bU @#V
R2@N
t W k 54 y
t W k 44 R
+? `
+? `
mMbB;M2/ BMi
mMbB;M2/ +? `
STL
vector
C++
Effective STL
string
p2+iQ`
new
delete
delete
new
BMi
`v 4 M2r BMi (`QrnMmK)c
7Q`UBMi B 4 yc B I `QrnMmKc YYBV
`v(B) 4 M2r BMi(+QHnMmK)c
vector
p2+iQ`Ip2+iQ`IBMi= = `vU`QrnMmK- p2+iQ`IBMi=U+QHnMmK- yVVc
reserve
BUG
2.1
2.1.1 Remove Duplicates from Sorted Array
Given a sorted array, remove the duplicates in place such that each element appear only once
and return the new length.
Do not allocate extra space for another array, you must do this in place with constant memory.
For example, Given input array 4 (R-R-k),
Your function should return length = 2, and A is now (R-k).
1
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ `` v
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp2.mTHB+ i2bUp2+iQ`IBMi= MmKbV &
B7 UMmKbX2KTivUVV `2im`M yc
'c
'
BMi BM/2t 4 yc
7Q` UBMi B 4 Rc B I MmKbXbBx2UVc BYYV &
B7 UMmKb(BM/2t) 54 MmKb(B)V
MmKb(YYBM/2t) 4 MmKb(B)c
'
`2im`M BM/2t Y Rc
2.1
2
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ `` v
ff
ahG
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp2.mTHB+ i2bUp2+iQ`IBMi= MmKbV &
`2im`M /Bbi M+2UMmKbX#2;BMUV- mMB[m2UMmKbX#2;BMUV- MmKbX2M/UVVVc
'
'c
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ `` v
ff
ahG
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp2.mTHB+ i2bUp2+iQ`IBMi= MmKbV &
`2im`M /Bbi M+2UMmKbX#2;BMUV- `2KQp2.mTHB+ i2bUMmKbX#2;BMUV- MmKbX2M/UV- MmKbX#2;BMUVV
'
i2KTH i2IivT2M K2 AMAi- ivT2M K2 PmiAi=
PmiAi `2KQp2.mTHB+ i2bUAMAi 7B`bi- AMAi H bi- PmiAi QmiTmiV &
r?BH2 U7B`bi 54 H biV &
QmiTmiYY 4 7B`bic
7B`bi 4 mTT2`n#QmM/U7B`bi- H bi- 7B`biVc
'
'c
'
`2im`M QmiTmic
Remove Duplicates from Sorted Array II
2.1.2
2.1.2 Remove Duplicates from Sorted Array II
Follow up for Remove Duplicates: What if duplicates are allowed at most twice?
For example, Given sorted array 4 (R-R-R-k-k-j),
Your function should return length = 5, and A is now (R-R-k-k-j)
hashmap
1
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ `` v AA
ff
PUMV
PURV
ff ! mi?Q` ?2tRy3 U?iiTb,ff;Bi?m#X+QKf?2tRy3V
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp2.mTHB+ i2bUp2+iQ`IBMi= MmKbV &
B7 UMmKbXbBx2UV I4 kV `2im`M MmKbXbBx2UVc
BMi BM/2t 4 kc
7Q` UBMi B 4 kc B I MmKbXbBx2UVc BYYV&
B7 UMmKb(B) 54 MmKb(BM/2t @ k)V
MmKb(BM/2tYY) 4 MmKb(B)c
'
'c
'
`2im`M BM/2tc
2
Q++m` I k
I j
Q++m`
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ `` v AA
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfmfReeeddNdk8V
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp2.mTHB+ i2bUp2+iQ`IBMi= MmKbV &
+QMbi BMi M 4 MmKbXbBx2UVc
BMi BM/2t 4 yc
7Q` UBMi B 4 yc B I Mc YYBV &
B7 UB = y B I M @ R MmKb(B) 44 MmKb(B @ R) MmKb(B) 44 MmKb(B Y R)V
+QMiBMm2c
'c
'
MmKb(BM/2tYY) 4 MmKb(B)c
'
`2im`M BM/2tc
Remove Duplicates from Sorted Array
2.1.1
2.1
2.1.3 Search in Rotated Sorted Array
Suppose a sorted array is rotated at some pivot unknown to you beforehand.
(i.e., y R k 9 8 e d might become 9 8 e d y R k).
You are given a target value to search. If found in the array return its index, otherwise return -1.
You may assume no duplicate exists in the array.
ff G22i*Q/2- a2 `+? BM _Qi i2/ aQ`i2/ `` v
ff
PUHQ; MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi b2 `+?U+QMbi p2+iQ`IBMi= MmKb- BMi i `;2iV
BMi 7B`bi 4 y- H bi 4 MmKbXbBx2UVc
r?BH2 U7B`bi 54 H biV &
+QMbi BMi KB/ 4 7B`bi Y UH bi @ 7B`biV
B7 UMmKb(KB/) 44 i `;2iV
`2im`M KB/c
B7 UMmKb(7B`bi) I4 MmKb(KB/)V &
B7 UMmKb(7B`bi) I4 i `;2i i `;2i
H bi 4 KB/c
2Hb2
7B`bi 4 KB/ Y Rc
' 2Hb2 &
B7 UMmKb(KB/) I i `;2i i `;2i I4
7B`bi 4 KB/ Y Rc
2Hb2
H bi 4 KB/c
'
'
`2im`M @Rc
'
'c
Search in Rotated Sorted Array II
2.1.4
&
f kc
I MmKb(KB/)V
MmKb(H bi@R)V
2.1.4 Search in Rotated Sorted Array II
Follow up for Search in Rotated Sorted Array: What if duplicates are allowed?
Would this affect the run-time complexity? How and why?
Write a function to determine if a given target is in the array.
(K)=4(H),
(H-K)
(R-j-R-R-R)
(K)=4(H)
(K)=(H)
(K)44(H)
(H-K)
HYY
ff G22i*Q/2- a2 `+? BM _Qi i2/ aQ`i2/ `` v AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH b2 `+?U+QMbi p2+iQ`IBMi= MmKb- BMi i `;2iV &
BMi 7B`bi 4 y- H bi 4 MmKbXbBx2UVc
r?BH2 U7B`bi 54 H biV &
+QMbi BMi KB/ 4 7B`bi Y UH bi @ 7B`biV f kc
B7 UMmKb(KB/) 44 i `;2iV
`2im`M i`m2c
B7 UMmKb(7B`bi) I MmKb(KB/)V &
B7 UMmKb(7B`bi) I4 i `;2i i `;2i I MmKb(KB/)V
H bi 4 KB/c
2Hb2
7B`bi 4 KB/ Y Rc
' 2Hb2 B7 UMmKb(7B`bi) = MmKb(KB/)V &
B7 UMmKb(KB/) I i `;2i i `;2i I4 MmKb(H bi@R)V
7B`bi 4 KB/ Y Rc
2Hb2
H bi 4 KB/c
' 2Hb2
ffbFBT /mTHB+ i2 QM2
7B`biYYc
'
`2im`M 7 Hb2c
'
'c
2.1
Search in Rotated Sorted Array
2.1.3
2.1.5 Median of Two Sorted Arrays
There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted
arrays. The overall run time complexity should be O(log(m + n)).
k
merge
O(m + n)
k
T
m
merge sort
B
T"YY
O(1)
T"
TYY
A
KYY
KYY
O(k)
m+n
O(m + n)
k
k
A
k
A
k/2
k/2
"(Ffk@R)
(Ffk@R)
k/2
k
(Ffk@R) 44 "(Ffk@R)
(Ffk@R) = "(Ffk@R)
(Ffk@R) I "(Ffk@R)
(Ffk@R) I "(Ffk@R)
(Ffk@R)
A
B
(Ffk@R)
k
AB
top k
(Ffk@R) = "(Ffk@R)
k/2
k/2
(Ffk@R) 44 "(Ffk@R)
(y)
AB
(Ffk@R)
A
B
"(F@R)
(F@R)
F4R
KBMU(y)- "(y)V
(Ffk@R) 44 "(Ffk@R)
(Ffk@R)
"(Ffk@R)
"(Ffk@R)
ff G22i*Q/2- J2/B M Q7 hrQ aQ`i2/ `` vb
ff
PUHQ;UKYMVV
PUHQ;UKYMVV
+H bb aQHmiBQM &
Tm#HB+,
/Qm#H2 7BM/J2/B MaQ`i2/`` vbU+QMbi p2+iQ`IBMi= - +QMbi p2+iQ`IBMi= "V &
+QMbi BMi K 4 XbBx2UVc
+QMbi BMi M 4 "XbBx2UVc
BMi iQi H 4 K Y Mc
B7 UiQi H ytRV
`2im`M 7BM/nFi?UX#2;BMUV- K- "X#2;BMUV- M- iQi H f k Y RVc
2Hb2
`2im`M U7BM/nFi?UX#2;BMUV- K- "X#2;BMUV- M- iQi H f kV
Y 7BM/nFi?UX#2;BMUV- K- "X#2;BMUV- M- iQi H f k Y RVV f kXyc
'
T`Bp i2,
bi iB+ BMi 7BM/nFi?Ubi/,,p2+iQ`IBMi=,,+QMbinBi2` iQ` - BMi Kbi/,,p2+iQ`IBMi=,,+QMbinBi2` iQ` "- BMi M- BMi FV &
ff Hr vb bbmK2 i? i K Bb 2[m H Q` bK HH2` i? M M
B7 UK = MV `2im`M 7BM/nFi?U"- M- - K- FVc
B7 UK 44 yV `2im`M U" Y F @ RVc
B7 UF 44 RV `2im`M KBMU - "Vc
'
'c
ff/BpB/2 F BMiQ irQ T `ib
BMi B 4 KBMUF f k- KV- B# 4 F @ B c
B7 U U Y B @ RV I U" Y B# @ RVV
`2im`M 7BM/nFi?U Y B - K @ B - "- M- F @ B Vc
2Hb2 B7 U U Y B @ RV = U" Y B# @ RVV
`2im`M 7BM/nFi?U- K- " Y B#- M @ B#- F @ B#Vc
2Hb2
`2im`M (B @ R)c
2.1.6 Longest Consecutive Sequence
Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
For example, Given (Ryy- 9- kyy- R- j- k), The longest consecutive elements sequence is (Rk- j- 9). Return its length: 4.
Your algorithm should run in O(n) complexity.
2.1
O(n log n)
O(n)
O(n)
mMQ`/2`2/nK TIBMi- #QQH= mb2/
ff G22i *Q/2- GQM;2bi *QMb2+miBp2 a2[m2M+2
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi HQM;2bi*QMb2+miBp2U+QMbi p2+iQ`IBMi= MmKbV &
mMQ`/2`2/nK TIBMi- #QQH= mb2/c
7Q` U miQ B , MmKbV mb2/(B) 4 7 Hb2c
BMi HQM;2bi 4 yc
7Q` U miQ B , MmKbV &
B7 Umb2/(B)V +QMiBMm2c
BMi H2M;i? 4 Rc
mb2/(B) 4 i`m2c
7Q` UBMi D 4 B Y Rc mb2/X7BM/UDV 54 mb2/X2M/UVc YYDV &
mb2/(D) 4 i`m2c
YYH2M;i?c
'
7Q` UBMi D 4 B @ Rc mb2/X7BM/UDV 54 mb2/X2M/UVc @@DV &
mb2/(D) 4 i`m2c
YYH2M;i?c
'
'
'c
'
HQM;2bi 4 K tUHQM;2bi- H2M;i?Vc
`2im`M HQM;2bic
2
,
.
K TIBMi- BMi= K T
,
.
union,find
.
,
mMQ`/2`2/n@
?iiT,ff/Bb+mbbXH22i+Q/2X+QKf[m2biBQMbfRydyf
10
HQM;2bi@+QMb2+miBp2@b2[m2M+2
ff G22i *Q/2- GQM;2bi *QMb2+miBp2 a2[m2M+2
ff
PUMV
PUMV
ff mi?Q`, ! /p M+2/tv
+H bb aQHmiBQM &
Tm#HB+,
BMi HQM;2bi*QMb2+miBp2Up2+iQ`IBMi= MmKbV &
mMQ`/2`2/nK TIBMi- BMi= K Tc
BMi bBx2 4 MmKbXbBx2UVc
BMi H 4 Rc
7Q` UBMi B 4 yc B I bBx2c BYYV &
B7 UK TX7BM/UMmKb(B)V 54 K TX2M/UVV +QMiBMm2c
K T(MmKb(B)) 4 Rc
B7 UK TX7BM/UMmKb(B) @ RV 54 K TX2M/UVV &
H 4 K tUH- K2`;2*Hmbi2`UK T- MmKb(B) @ R- MmKb(B)VVc
'
B7 UK TX7BM/UMmKb(B) Y RV 54 K TX2M/UVV &
H 4 K tUH- K2`;2*Hmbi2`UK T- MmKb(B)- MmKb(B) Y RVVc
'
'
`2im`M bBx2 44 y \ y , Hc
'
T`Bp i2,
BMi K2`;2*Hmbi2`UmMQ`/2`2/nK TIBMi- BMi= K T- BMi H27i- BMi `B;?iV &
BMi mTT2` 4 `B;?i Y K T(`B;?i) @ Rc
BMi HQr2` 4 H27i @ K T(H27i) Y Rc
BMi H2M;i? 4 mTT2` @ HQr2` Y Rc
K T(mTT2`) 4 H2M;i?c
K T(HQr2`) 4 H2M;i?c
`2im`M H2M;i?c
'
'c
2.1.7 Two Sum
Given an array of integers, find two numbers such that they add up to a specific target number.
The function twoSum should return indices of the two numbers such that they add up to the target, where
index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not
zero-based.
11
2.1
You may assume that each input would have exactly one solution.
Input: MmK#2`b4&k- d- RR- R8'- i `;2i4N
Output: BM/2tR4R- BM/2tk4k
O(n2 )
1
2
hash
O(n).
O(n log n)
O(n)
O(n log n)
ffG22i*Q/2- hrQ amK
ff
k ? b?
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= irQamKUp2+iQ`IBMi= MmKb- BMi i `;2iV &
mMQ`/2`2/nK TIBMi- BMi= K TTBM;c
p2+iQ`IBMi= `2bmHic
7Q` UBMi B 4 yc B I MmKbXbBx2UVc BYYV &
K TTBM;(MmKb(B)) 4 Bc
'
7Q` UBMi B 4 yc B I MmKbXbBx2UVc BYYV &
+QMbi BMi ; T 4 i `;2i @ MmKb(B)c
B7 UK TTBM;X7BM/U; TV 54 K TTBM;X2M/UV K TTBM;(; T) = BV &
`2bmHiXTmb?n# +FUB Y RVc
`2bmHiXTmb?n# +FUK TTBM;(; T) Y RVc
#`2 Fc
'
'
`2im`M `2bmHic
'
'c
3Sum,
2.1.8
3Sum Closest,
4Sum,
2.1.10
2.1.9
12
2.1.8 3Sum
Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique
triplets in the array which gives the sum of zero.
Note:
Elements in a triplet (a, b, c) must be in non-descending order. (ie, a b c)
The solution set must not contain duplicate triplets.
For example, given array a 4 &@R y R k @R @9'.
A solution set is:
U@R- y- RV
U@R- @R- kV
O(n2 )
k-sum
O(max{n log n, n
k1
})
k2
ff G22i*Q/2- jamK
ff
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi== i?`22amKUp2+iQ`IBMi= MmKbV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
B7 UMmKbXbBx2UV I jV `2im`M `2bmHic
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
+QMbi BMi i `;2i 4 yc
miQ H bi 4 MmKbX2M/UVc
7Q` U miQ B 4 MmKbX#2;BMUVc B I H bi@kc YYBV &
miQ D 4 BYRc
B7 UB = MmKbX#2;BMUV B 44 UB@RVV +QMiBMm2c
miQ F 4 H bi@Rc
r?BH2 UD I FV &
B7 U B Y D Y F I i `;2iV &
YYDc
r?BH2U D 44 UD @ RV D I FV YYDc
' 2Hb2 B7 U B Y D Y F = i `;2iV &
@@Fc
r?BH2U F 44 UF Y RV D I FV @@Fc
' 2Hb2 &
`2bmHiXTmb?n# +FU& B- D- F 'Vc
YYDc
PURV
13
2.1
@@Fc
r?BH2U D 44
'
'c
'
UD @ RV
F 44
UF Y RV D I FV YYDc
'
'
`2im`M `2bmHic
Two sum,
2.1.7
3Sum Closest,
4Sum,
2.1.9
2.1.10
2.1.9 3Sum Closest
Given an array S of n integers, find three integers in S such that the sum is closest to a given number,
target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
For example, given array a 4 &@R k R @9', and i `;2i 4 R.
The sum that is closest to the target is 2. (@R Y k Y R 4 k).
O(n2 )
ff G22i*Q/2- jamK *HQb2bi
ff
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi i?`22amK*HQb2biUp2+iQ`IBMi= MmKb- BMi i `;2iV &
BMi `2bmHi 4 yc
BMi KBMn; T 4 ALhnJsc
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
7Q` U miQ 4 MmKbX#2;BMUVc 54 T`2pUMmKbX2M/UV- kVc YY V &
miQ # 4 M2tiU Vc
miQ + 4 T`2pUMmKbX2M/UVVc
r?BH2 U# I +V &
+QMbi BMi bmK 4 Y # Y +c
+QMbi BMi ; T 4 #bUbmK @ i `;2iVc
14
B7 U; T I KBMn; TV &
`2bmHi 4 bmKc
KBMn; T 4 ; Tc
'
'
'c
'
B7 UbmK I i `;2iV YY#c
2Hb2
@@+c
'
`2im`M `2bmHic
Two sum,
2.1.7
3Sum,
2.1.8
4Sum,
2.1.10
2.1.10 4Sum
Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target?
Find all unique quadruplets in the array which gives the sum of target.
Note:
Elements in a quadruplet (a, b, c, d) must be in non-descending order. (ie, a b c d)
The solution set must not contain duplicate quadruplets.
For example, given array a 4 &R y @R y @k k', and i `;2i 4 y.
A solution set is:
U@R- y- y- RV
U@k- @R- R- kV
U@k- y- y- kV
O(n3 )
hashmap
O(n3 )
3Sum
15
2.1
ff G22i*Q/2- 9amK
ff
PUM jV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi== 7Qm`amKUp2+iQ`IBMi= MmKb- BMi i `;2iV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
B7 UMmKbXbBx2UV I 9V `2im`M `2bmHic
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
'c
'
miQ H bi 4 MmKbX2M/UVc
7Q` U miQ 4 MmKbX#2;BMUVc I T`2pUH bi- jVc YY V &
7Q` U miQ # 4 M2tiU Vc # I T`2pUH bi- kVc YY#V &
miQ + 4 M2tiU#Vc
miQ / 4 T`2pUH biVc
r?BH2 U+ I /V &
B7 U Y # Y + Y / I i `;2iV &
YY+c
' 2Hb2 B7 U Y # Y + Y / = i `;2iV &
@@/c
' 2Hb2 &
`2bmHiXTmb?n# +FU& - #- +- / 'Vc
YY+c
@@/c
'
'
'
'
bQ`iU`2bmHiX#2;BMUV- `2bmHiX2M/UVVc
`2bmHiX2` b2UmMB[m2U`2bmHiX#2;BMUV- `2bmHiX2M/UVV- `2bmHiX2M/UVVc
`2im`M `2bmHic
map
ff G22i*Q/2- 9amK
ff
? b?K T
ff
PUM kV
PUM 9V
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = 7Qm`amKUp2+iQ`IBMi= MmKb- BMi i `;2iV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
B7 UMmKbXbBx2UV I 9V `2im`M `2bmHic
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
mMQ`/2`2/nK TIBMi- p2+iQ`IT B`IBMi- BMi= = = + +?2c
7Q` UbBx2ni 4 yc I MmKbXbBx2UVc YY V &
7Q` UbBx2ni # 4 Y Rc # I MmKbXbBx2UVc YY#V &
+ +?2(MmKb( ) Y MmKb(#))XTmb?n# +FUT B`IBMi- BMi=U - #VVc
'
'
16
7Q` UBMi + 4 yc + I MmKbXbBx2UVc YY+V &
7Q` UbBx2ni / 4 + Y Rc / I MmKbXbBx2UVc YY/V &
+QMbi BMi F2v 4 i `;2i @ MmKb(+) @ MmKb(/)c
B7 U+ +?2X7BM/UF2vV 44 + +?2X2M/UVV +QMiBMm2c
+QMbi miQ p2+ 4 + +?2(F2v)c
7Q` UbBx2ni F 4 yc F I p2+XbBx2UVc YYFV &
B7 U+ I4 p2+(F)Xb2+QM/V
+QMiBMm2c ff
'
'c
'
'
`2bmHiXTmb?n# +FU & MmKb(p2+(F)X7B`bi)MmKb(p2+(F)Xb2+QM/)- MmKb(+)- MmKb(/) 'Vc
'
bQ`iU`2bmHiX#2;BMUV- `2bmHiX2M/UVVc
`2bmHiX2` b2UmMB[m2U`2bmHiX#2;BMUV- `2bmHiX2M/UVV- `2bmHiX2M/UVVc
`2im`M `2bmHic
multimap
ff G22i*Q/2- 9amK
ff
? b?K T
ff
PUM kV
PUM kV
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHm M;QM;V
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi== 7Qm`amKUp2+iQ`IBMi= MmKb- BMi i `;2iV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
B7 UMmKbXbBx2UV I 9V `2im`M `2bmHic
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
mMQ`/2`2/nKmHiBK TIBMi- T B`IBMi- BMi== + +?2c
7Q` UBMi B 4 yc B Y R I MmKbXbBx2UVc YYBV
7Q` UBMi D 4 B Y Rc D I MmKbXbBx2UVc YYDV
+ +?2XBMb2`iUK F2nT B`UMmKb(B) Y MmKb(D)- K F2nT B`UB- DVVVc
7Q` U miQ B 4 + +?2X#2;BMUVc B 54 + +?2X2M/UVc YYBV &
BMi t 4 i `;2i @ B@=7B`bic
miQ ` M;2 4 + +?2X2[m Hn` M;2UtVc
7Q` U miQ D 4 ` M;2X7B`bic D 54 ` M;2Xb2+QM/c YYDV &
miQ 4 B@=b2+QM/X7B`bic
miQ # 4 B@=b2+QM/Xb2+QM/c
miQ + 4 D@=b2+QM/X7B`bic
miQ / 4 D@=b2+QM/Xb2+QM/c
B7 U 54 + 54 / # 54 + # 54 /V &
p2+iQ`IBMi= p2+ 4 & MmKb( )- MmKb(#)- MmKb(+)- MmKb(/) 'c
bQ`iUp2+X#2;BMUV- p2+X2M/UVVc
`2bmHiXTmb?n# +FUp2+Vc
'
17
2.1
'c
'
'
'
bQ`iU`2bmHiX#2;BMUV- `2bmHiX2M/UVVc
`2bmHiX2` b2UmMB[m2U`2bmHiX#2;BMUV- `2bmHiX2M/UVV- `2bmHiX2M/UVVc
`2im`M `2bmHic
4
ff G22i*Q/2- 9amK
ff
PUM jHQ;MV
PURV
ff
R
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi== 7Qm`amKUp2+iQ`IBMi= MmKb- BMi i `;2iV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
B7 UMmKbXbBx2UV I 9V `2im`M `2bmHic
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
'c
'
miQ H bi 4 MmKbX2M/UVc
7Q` U miQ 4 MmKbX#2;BMUVc I T`2pUH bi- jVc
4 mTT2`n#QmM/U - T`2pUH bi- jV- VV &
7Q` U miQ # 4 M2tiU Vc # I T`2pUH bi- kVc
# 4 mTT2`n#QmM/U#- T`2pUH bi- kV- #VV &
miQ + 4 M2tiU#Vc
miQ / 4 T`2pUH biVc
r?BH2 U+ I /V &
B7 U Y # Y + Y / I i `;2iV &
+ 4 mTT2`n#QmM/U+- /- +Vc
' 2Hb2 B7 U Y # Y + Y / = i `;2iV &
/ 4 T`2pUHQr2`n#QmM/U+- /- /VVc
' 2Hb2 &
`2bmHiXTmb?n# +FU& - #- +- / 'Vc
+ 4 mTT2`n#QmM/U+- /- +Vc
/ 4 T`2pUHQr2`n#QmM/U+- /- /VVc
'
'
'
'
`2im`M `2bmHic
Two sum,
3Sum,
2.1.7
2.1.8
3Sum Closest,
2.1.9
18
2.1.11 Remove Element
Given an array and a value, remove all instances of that value in place and return the new length.
The order of elements can be changed. It doesnt matter what you leave beyond the new length.
1
ff G22i*Q/2- _2KQp2 1H2K2Mi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp21H2K2MiUp2+iQ`IBMi= MmKb- BMi i `;2iV &
BMi BM/2t 4 yc
7Q` UBMi B 4 yc B I MmKbXbBx2UVc YYBV &
B7 UMmKb(B) 54 i `;2iV &
MmKb(BM/2tYY) 4 MmKb(B)c
'
'
`2im`M BM/2tc
'
'c
2
ff G22i*Q/2- _2KQp2 1H2K2Mi
ff
`2KQp2UV
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi `2KQp21H2K2MiUp2+iQ`IBMi= MmKb- BMi i `;2iV &
`2im`M /Bbi M+2UMmKbX#2;BMUV- `2KQp2UMmKbX#2;BMUV- MmKbX2M/UV- i `;2iVVc
'
'c
19
2.1
2.1.12 Next Permutation
Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.
If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).
The replacement must be in-place, do not allocate extra memory.
Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the
right-hand column.
R-k-j R-j-k
j-k-R R-k-j
R-R-8 R-8-R
2-1
http://sherlei.blogspot.com/2012/12/leetcode-next-permutation.html
2-1
20
ff G22i*Q/2- L2ti S2`Kmi iBQM
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ M2tiS2`Kmi iBQMUp2+iQ`IBMi= MmKbV &
M2tinT2`Kmi iBQMUMmKbX#2;BMUV- MmKbX2M/UVVc
'
i2KTH i2IivT2M K2 "B/BAi=
#QQH M2tinT2`Kmi iBQMU"B/BAi 7B`bi- "B/BAi H biV &
ff :2i `2p2`b2/ ` M;2 iQ bBKTHB7v `2p2`b2/ i` p2`b HX
+QMbi miQ `7B`bi 4 `2p2`b2nBi2` iQ`I"B/BAi=UH biVc
+QMbi miQ `H bi 4 `2p2`b2nBi2` iQ`I"B/BAi=U7B`biVc
ff "2;BM 7`QK i?2 b2+QM/ H bi 2H2K2Mi iQ i?2 7B`bi 2H2K2MiX
miQ TBpQi 4 M2tiU`7B`biVc
ff 6BM/ <TBpQi<- r?B+? Bb i?2 7B`bi 2H2K2Mi i? i Bb MQ H2bb i? M Bib
ff bm++2bbQ`X <S`2p< Bb mb2/ bBM+2 <TBpQ`i< Bb <`2p2`b2/nBi2` iQ`<X
r?BH2 UTBpQi 54 `H bi TBpQi =4 T`2pUTBpQiVV
YYTBpQic
ff LQ bm+? 2H2K2M2i 7QmM/- +m``2Mi b2[m2M+2 Bb H`2 /v i?2 H `;2bi
ff T2`Kmi iBQM- i?2M `2 `` M;2 iQ i?2 7B`bi T2`Kmi iBQM M/ `2im`M 7 Hb2X
B7 UTBpQi 44 `H biV &
`2p2`b2U`7B`bi- `H biVc
`2im`M 7 Hb2c
'
ff a+ M 7`QK `B;?i iQ H27i- 7BM/ i?2 7B`bi 2H2K2Mi i? i Bb ;`2 i2` i? M
ff <TBpQi<X
miQ +? M;2 4 7BM/nB7U`7B`bi- TBpQi- #BM/RbiUH2bbIBMi=UV- TBpQiVVc
br TU +? M;2- TBpQiVc
`2p2`b2U`7B`bi- TBpQiVc
'c
'
`2im`M i`m2c
Permutation Sequence,
Permutations,
Permutations II,
Combinations,
8.3
8.4
8.5
2.1.13
21
2.1
2.1.13 Permutation Sequence
The set (R-k-j-
-M) contains a total of n! unique permutations.
By listing and labeling all of the permutations in order, We get the following sequence (ie, for n = 3):
]Rkj]
]Rjk]
]kRj]
]kjR]
]jRk]
]jkR]
Given n and k, return the kth permutation sequence.
Note: Given n will be between 1 and 9 inclusive.
M2tinT2`Kmi iBQMUV
k1
n
a2 , a3 , ..., an ,
a1
a2 , a3 , ..., an
a1 = k/(n 1)!
a1 , a2 , a3 , ..., an
n1
k2
k%(n 1)!
a2
k2 /(n 2)!
kn1
kn2 %2!
an1
kn1 /1!
an
next_permutation()
ff G22i*Q/2- S2`Kmi iBQM a2[m2M+2
ff
M2tinT2`Kmi iBQMUV hG1
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; ;2iS2`Kmi iBQMUBMi M- BMi FV &
bi`BM; bUM- ^y^Vc
7Q` UBMi B 4 yc B I Mc YYBV
n1
a1
(n 1)!
22
'
'c
b(B) Y4 BYRc
7Q` UBMi B 4 yc B I F@Rc YYBV
M2tinT2`Kmi iBQMUbX#2;BMUV- bX2M/UVVc
`2im`M bc
i2KTH i2IivT2M K2 "B/BAi=
#QQH M2tinT2`Kmi iBQMU"B/BAi 7B`bi- "B/BAi H biV &
ff
L2ti S2`Kmi iBQM
'
ff G22i*Q/2- S2`Kmi iBQM a2[m2M+2
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; ;2iS2`Kmi iBQMUBMi M- BMi FV &
bi`BM; bUM- ^y^Vc
bi`BM; `2bmHic
7Q` UBMi B 4 yc B I Mc YYBV
b(B) Y4 B Y Rc
`2im`M Fi?nT2`Kmi iBQMUb- FVc
'
T`Bp i2,
BMi 7 +iQ`B HUBMi MV &
BMi `2bmHi 4 Rc
7Q` UBMi B 4 Rc B I4 Mc YYBV
`2bmHi 4 Bc
`2im`M `2bmHic
'
ff b2[
i2KTH i2IivT2M K2 a2[m2M+2=
a2[m2M+2 Fi?nT2`Kmi iBQMU+QMbi a2[m2M+2 b2[- BMi FV &
+QMbi BMi M 4 b2[XbBx2UVc
a2[m2M+2 aUb2[Vc
a2[m2M+2 `2bmHic
BMi # b2 4 7 +iQ`B HUM @ RVc
@@Fc ff
y
7Q` UBMi B 4 M @ Rc B = yc F W4 # b2- # b2 f4 B- @@BV &
miQ 4 M2tiUaX#2;BMUV- F f # b2Vc
`2bmHiXTmb?n# +FU Vc
aX2` b2U Vc
'
'
`2bmHiXTmb?n# +FUa(y)Vc ff
`2im`M `2bmHic
23
2.1
'c
Next Permutation,
Permutations,
2.1.12
8.3
Permutations II,
Combinations,
8.4
8.5
2.1.14 Valid Sudoku
Determine
if
Sudoku
is
valid,
according
to:
Sudoku
Puzzles
The
http://sudoku.com.au/TheRules.aspx .
The Sudoku board could be partially filled, where empty cells are filled with the character ^X^.
2-2 A partially filled sudoku which is valid
ff G22i*Q/2- o HB/ am/QFm
ff
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bbo HB/am/QFmU+QMbi p2+iQ`Ip2+iQ`I+? `== #Q `/V &
#QQH mb2/(N)c
Rules
24
7Q` UBMi B 4 yc B I Nc YYBV &
7BHHUmb2/- mb2/ Y N- 7 Hb2Vc
7Q` UBMi D 4 yc D I Nc YYDV ff
B7 U5+?2+FU#Q `/(B)(D)- mb2/VV
`2im`M 7 Hb2c
7BHHUmb2/- mb2/ Y N- 7 Hb2Vc
'
7Q` UBMi D 4 yc D I Nc YYDV ff
B7 U5+?2+FU#Q `/(D)(B)- mb2/VV
`2im`M 7 Hb2c
7Q` UBMi ` 4 yc ` I jc YY`V ff
N
7Q` UBMi + 4 yc + I jc YY+V &
7BHHUmb2/- mb2/ Y N- 7 Hb2Vc
'
'
7Q` UBMi B 4 `
jc B I `
j Y jc YYBV
7Q` UBMi D 4 +
jc D I +
j Y jc YYDV
B7 U5+?2+FU#Q `/(B)(D)- mb2/VV
`2im`M 7 Hb2c
`2im`M i`m2c
#QQH +?2+FU+? ` +?- #QQH mb2/(N)V &
B7 U+? 44 ^X^V `2im`M i`m2c
B7 Umb2/(+? @ ^R^)V `2im`M 7 Hb2c
'c
'
`2im`M mb2/(+? @ ^R^) 4 i`m2c
Sudoku Solver,
10.10
2.1.15 Trapping Rain Water
Given n non-negative integers representing an elevation map where the width of each bar is 1, compute
how much water it is able to trap after raining.
For example, Given (y-R-y-k-R-y-R-j-k-R-k-R), return 6.
25
2.1
2-3
Trapping Rain Water
KBMUK tnH27i- K tn@
`B;?iV @ ?2B;?i
1.
2.
3.
1.
2.
3.
1
ff G22i*Q/2- h` TTBM; _ BM q i2`
ff
R
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi i` TU+QMbi p2+iQ`IBMi= V &
+QMbi BMi M 4 XbBx2UVc
BMi K tnH27i 4 M2r BMi(M)UVc
BMi K tn`B;?i 4 M2r BMi(M)UVc
7Q` UBMi B 4 Rc B I Mc BYYV &
K tnH27i(B) 4 K tUK tnH27i(B @ R)- (B @ R)Vc
K tn`B;?i(M @ R @ B) 4 K tUK tn`B;?i(M @ B)- (M @ B)Vc
'
BMi bmK 4 yc
7Q` UBMi B 4 yc B I Mc BYYV &
26
'
'c
'
BMi ?2B;?i 4 KBMUK tnH27i(B)- K tn`B;?i(B)Vc
B7 U?2B;?i = (B)V &
bmK Y4 ?2B;?i @ (B)c
'
/2H2i2() K tnH27ic
/2H2i2() K tn`B;?ic
`2im`M bmKc
2
ff G22i*Q/2- h` TTBM; _ BM q i2`
ff
k
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi i` TU+QMbi p2+iQ`IBMi= V &
+QMbi BMi M 4 XbBx2UVc
BMi K t 4 yc ff
7Q` UBMi B 4 yc B I Mc BYYV
B7 U(B) = (K t)V K t 4 Bc
'c
'
BMi r i2` 4 yc
7Q` UBMi B 4 y- T2 F 4 yc B I K tc BYYV
B7 U(B) = T2 FV T2 F 4 (B)c
2Hb2 r i2` Y4 T2 F @ (B)c
7Q` UBMi B 4 M @ R- iQT 4 yc B = K tc B@@V
B7 U(B) = iQTV iQT 4 (B)c
2Hb2 r i2` Y4 iQT @ (B)c
`2im`M r i2`c
ff G22i*Q/2- h` TTBM; _ BM q i2`
ff
ff
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi i` TU+QMbi p2+iQ`IBMi= V &
+QMbi BMi M 4 XbBx2UVc
bi +FIT B`IBMi- BMi== bc
BMi r i2` 4 yc
7Q` UBMi B 4 yc B I Mc YYBV &
27
2.1
BMi ?2B;?i 4 yc
r?BH2 U5bX2KTivUVV & ff
BMi # ` 4 bXiQTUVX7B`bic
BMi TQb 4 bXiQTUVXb2+QM/c
ff # `- ?2B;?i- (B)
r i2` Y4 UKBMU# `- (B)V @ ?2B;?iV
?2B;?i 4 # `c
'
'
'c
'
B7 U(B) I # `V ff
#`2 Fc
2Hb2
bXTQTUVc ff
bXTmb?UK F2nT B`U(B)- BVVc
`2im`M r i2`c
Container With Most Water,
12.6
Largest Rectangle in Histogram,
4.1.3
2.1.16 Rotate Image
You are given an n n 2D matrix representing an image.
Rotate the image by 90 degrees (clockwise).
Follow up: Could you do this in-place?
2-4 Rotate Image
UB @ TQb @ RVc
28
1
ff G22i*Q/2- _Qi i2 AK ;2
ff
R
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ `Qi i2Up2+iQ`Ip2+iQ`IBMi== K i`BtV &
+QMbi BMi M 4 K i`BtXbBx2UVc
7Q` UBMi B 4 yc B I Mc YYBV ff
7Q` UBMi D 4 yc D I M @ Bc YYDV
br TUK i`Bt(B)(D)- K i`Bt(M @ R @ D)(M @ R @ B)Vc
'
'c
7Q` UBMi B 4 yc B I M f kc YYBV ff
7Q` UBMi D 4 yc D I Mc YYDV
br TUK i`Bt(B)(D)- K i`Bt(M @ R @ B)(D)Vc
2
ff G22i*Q/2- _Qi i2 AK ;2
ff
k
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ `Qi i2Up2+iQ`Ip2+iQ`IBMi== K i`BtV &
+QMbi BMi M 4 K i`BtXbBx2UVc
7Q` UBMi B 4 yc B I M f kc YYBV ff
7Q` UBMi D 4 yc D I Mc YYDV
br TUK i`Bt(B)(D)- K i`Bt(M @ R @ B)(D)Vc
'
'c
7Q` UBMi B 4 yc B I Mc YYBV ff
7Q` UBMi D 4 B Y Rc D I Mc YYDV
br TUK i`Bt(B)(D)- K i`Bt(D)(B)Vc
2.1.17 Plus One
Given a number represented as an array of digits, plus one to the number.
29
2.1
1
ff G22i*Q/2- SHmb PM2
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= THmbPM2Up2+iQ`IBMi= /B;BibV &
//U/B;Bib- RVc
`2im`M /B;Bibc
'
T`Bp i2,
ff y I4 /B;Bi I4 N
pQB/ //Up2+iQ`IBMi= /B;Bib- BMi /B;BiV &
BMi + 4 /B;Bic ff + ``v7Q` U miQ Bi 4 /B;BibX`#2;BMUVc Bi 54 /B;BibX`2M/UVc YYBiV &
Bi Y4 +c
+ 4 Bi f Ryc
Bi W4 Ryc
'
'c
'
B7 U+ = yV /B;BibXBMb2`iU/B;BibX#2;BMUV- RVc
2
ff G22i*Q/2- SHmb PM2
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= THmbPM2Up2+iQ`IBMi= /B;BibV &
//U/B;Bib- RVc
`2im`M /B;Bibc
'
T`Bp i2,
ff y I4 /B;Bi I4 N
pQB/ //Up2+iQ`IBMi= /B;Bib- BMi /B;BiV &
BMi + 4 /B;Bic ff + ``v7Q`n2 +?U/B;BibX`#2;BMUV- /B;BibX`2M/UV- ( +)UBMi /V&
/ Y4 +c
+ 4 / f Ryc
/ W4 Ryc
'Vc
B7 U+ = yV /B;BibXBMb2`iU/B;BibX#2;BMUV- RVc
30
2
'
'c
2.1.18 Climbing Stairs
You are climbing a stair case. It takes n steps to reach to the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
f (n)
n1
n1
n
1
2
f (n) = f (n 1) + f (n 2)
1
ff G22i*Q/2- *HBK#BM; ai B`b
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi +HBK#ai B`bUBMi MV &
BMi T`2p 4 yc
BMi +m` 4 Rc
7Q`UBMi B 4 Rc B I4 M c YYBV&
BMi iKT 4 +m`c
+m` Y4 T`2pc
T`2p 4 iKTc
'
`2im`M +m`c
'
'c
1
an =
5
!"
#n "
#n $
1+ 5
1 5
2
2
31
2.1
ff G22i*Q/2- *HBK#BM; ai B`b
ff
PURV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi +HBK#ai B`bUBMi MV &
+QMbi /Qm#H2 b 4 b[`iU8Vc
`2im`M 7HQQ`UUTQrUURYbVfk- MYRV Y TQrUUR@bVfk- MYRVVfb Y yX8Vc
'
'c
Decode Ways,
13.10
2.1.19 Gray Code
The gray code is a binary numeral system where two successive values differ in only one bit.
Given a non-negative integer n representing the total number of bits in the code, print the sequence of
gray code. A gray code sequence must begin with 0.
For example, given n = 2, return (y-R-j-k). Its gray code sequence is:
yy
yR
RR
Ry
@
@
@
@
y
R
j
k
Note:
For a given n, a gray code sequence is not uniquely defined.
For example, (y-k-j-R) is also a valid gray code sequence according to the above definition.
For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.
http://en.wikipedia.org/wiki/Gray_code
(Gray Code)
g0 = b0 , gi = bi bi1
1001
1
0
4
0
3
1
3
2
0
1101
b0 = g0 , bi = gi bi1
2
1
32
1000
1
4
n
n1
2-5
1
1
2-5
The first few steps of the reflect-and-prefix method.
ff G22i*Q/2- :` v *Q/2
ff
PUk MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= ;` v*Q/2UBMi MV &
p2+iQ`IBMi= `2bmHic
+QMbi bBx2ni bBx2 4 R II Mc ff k M
`2bmHiX`2b2`p2UbBx2Vc
7Q` UbBx2ni B 4 yc B I bBx2c YYBV
`2bmHiXTmb?n# +FU#BM `vniQn;` vUBVVc
`2im`M `2bmHic
'
T`Bp i2,
bi iB+ mMbB;M2/ BMi #BM `vniQn;` vUmMbB;M2/ BMi MV &
`2im`M M UM == RVc
'
'c
n (n/2)
0 2n 1
1
2
2
3
1111
n
33
2.1
Reflect-and-prefix method
ff G22i*Q/2- :` v *Q/2
ff `27H2+i@ M/@T`27Bt K2i?Q/
ff
PUk MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= ;` v*Q/2UBMi MV &
p2+iQ`IBMi= `2bmHic
`2bmHiX`2b2`p2URIIMVc
`2bmHiXTmb?n# +FUyVc
7Q` UBMi B 4 yc B I Mc BYYV &
+QMbi BMi ?B;?2bin#Bi 4 R II Bc
7Q` UBMi D 4 `2bmHiXbBx2UV @ Rc D =4 yc D@@V ff
`2bmHiXTmb?n# +FU?B;?2bin#Bi % `2bmHi(D)Vc
'
`2im`M `2bmHic
'
'c
2.1.20 Set Matrix Zeroes
Given a m n matrix, if an element is 0, set its entire row and column to 0. Do it in place.
Follow up: Did you use extra space?
A straight forward solution using O(mn) space is probably a bad idea.
A simple improvement uses O(m + n) space, but still not the best solution.
Could you devise a constant space solution?
O(m + n)
bool
1
ff G22i*Q/2- a2i J i`Bt w2`Q2b
ff
PUK MV
PUKYMV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ b2iw2`Q2bUp2+iQ`Ip2+iQ`IBMi= = K i`BtV &
+QMbi bBx2ni K 4 K i`BtXbBx2UVc
+QMbi bBx2ni M 4 K i`Bt(y)XbBx2UVc
34
2
p2+iQ`I#QQH= `QrUK- 7 Hb2Vc ff
p2+iQ`I#QQH= +QHUM- 7 Hb2Vc ff
y
y
7Q` UbBx2ni B 4 yc B I Kc YYBV &
7Q` UbBx2ni D 4 yc D I Mc YYDV &
B7 UK i`Bt(B)(D) 44 yV &
`Qr(B) 4 +QH(D) 4 i`m2c
'
'
'
'c
'
7Q` UbBx2ni B 4 yc B I Kc YYBV &
B7 U`Qr(B)V
7BHHU K i`Bt(B)(y)- K i`Bt(B)(y) Y M- yVc
'
7Q` UbBx2ni D 4 yc D I Mc YYDV &
B7 U+QH(D)V &
7Q` UbBx2ni B 4 yc B I Kc YYBV &
K i`Bt(B)(D) 4 yc
'
'
'
2
ff G22i*Q/2- a2i J i`Bt w2`Q2b
ff
PUK MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ b2iw2`Q2bUp2+iQ`Ip2+iQ`IBMi= = K i`BtV &
+QMbi bBx2ni K 4 K i`BtXbBx2UVc
+QMbi bBx2ni M 4 K i`Bt(y)XbBx2UVc
#QQH `Qrn? bnx2`Q 4 7 Hb2c ff
#QQH +QHn? bnx2`Q 4 7 Hb2c ff
7Q` UbBx2ni B 4 yc B I Mc BYYV
B7 UK i`Bt(y)(B) 44 yV &
`Qrn? bnx2`Q 4 i`m2c
#`2 Fc
'
7Q` UbBx2ni B 4 yc B I Kc BYYV
B7 UK i`Bt(B)(y) 44 yV &
+QHn? bnx2`Q 4 i`m2c
#`2 Fc
'
7Q` UbBx2ni B 4 Rc B I Kc BYYV
7Q` UbBx2ni D 4 Rc D I Mc DYYV
B7 UK i`Bt(B)(D) 44 yV &
K i`Bt(y)(D) 4 yc
y
y
35
2.1
'
'c
K i`Bt(B)(y) 4 yc
'
7Q` UbBx2ni B 4 Rc B I Kc BYYV
7Q` UbBx2ni D 4 Rc D I Mc DYYV
B7 UK i`Bt(B)(y) 44 y %% K i`Bt(y)(D) 44 yV
K i`Bt(B)(D) 4 yc
B7 U`Qrn? bnx2`QV
7Q` UbBx2ni B 4 yc B I Mc BYYV
K i`Bt(y)(B) 4 yc
B7 U+QHn? bnx2`QV
7Q` UbBx2ni B 4 yc B I Kc BYYV
K i`Bt(B)(y) 4 yc
2.1.21 Gas Station
There are N gas stations along a circular route, where the amount of gas at station i is ; b(B).
You have a car with an unlimited gas tank and it costs +Qbi(B) of gas to travel from station i to its next
station (i+1). You begin the journey with an empty tank at one of the gas stations.
Return the starting gas stations index if you can travel around the circuit once, otherwise return -1.
Note: The solution is guaranteed to be unique.
O(N 2 )
O(N )
bmK
bmK
iQi H
-1
ff G22i*Q/2- : b ai iBQM
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi + M*QKTH2i2*B`+mBiUp2+iQ`IBMi= ; b- p2+iQ`IBMi= +QbiV &
BMi iQi H 4 yc
BMi D 4 @Rc
7Q` UBMi B 4 y- bmK 4 yc B I ; bXbBx2UVc YYBV &
bmK Y4 ; b(B) @ +Qbi(B)c
iQi H Y4 ; b(B) @ +Qbi(B)c
36
2
B7 UbmK I yV &
D 4 Bc
bmK 4 yc
'
'
'c
'
`2im`M iQi H =4 y \ D Y R , @Rc
2.1.22 Candy
There are N children standing in a line. Each child is assigned a rating value.
You are giving candies to these children subjected to the following requirements:
Each child must have at least one candy.
Children with a higher rating get more candies than their neighbors.
What is the minimum candies you must give?
ff G22i*Q/2- * M/v
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi + M/vUp2+iQ`IBMi= ` iBM;bV &
+QMbi BMi M 4 ` iBM;bXbBx2UVc
p2+iQ`IBMi= BM+`2K2MiUMVc
ff
7Q` UBMi B 4 R- BM+ 4 Rc B I Mc BYYV &
B7 U` iBM;b(B) = ` iBM;b(B @ R)V
BM+`2K2Mi(B) 4 K tUBM+YY- BM+`2K2Mi(B)Vc
2Hb2
BM+ 4 Rc
'
7Q` UBMi B 4 M @ k- BM+ 4 Rc B =4 yc B@@V &
B7 U` iBM;b(B) = ` iBM;b(B Y R)V
37
2.1
2Hb2
'
'c
BM+`2K2Mi(B) 4 K tUBM+YY- BM+`2K2Mi(B)Vc
BM+ 4 Rc
'
ff
M
`2im`M ++mKmH i2U BM+`2K2Mi(y)- BM+`2K2Mi(y)YM- MVc
ff G22i*Q/2- * M/v
ff
PUMV
PUMV
ff ! mi?Q` 7 M+vKQmb2 U?iiT,ffr2B#QX+QKfmfRNk3Rek3kkV
+H bb aQHmiBQM &
Tm#HB+,
BMi + M/vU+QMbi p2+iQ`IBMi= ` iBM;bV &
p2+iQ`IBMi= 7U` iBM;bXbBx2UVVc
BMi bmK 4 yc
7Q` UBMi B 4 yc B I ` iBM;bXbBx2UVc YYBV
bmK Y4 bQHp2U` iBM;b- 7- BVc
`2im`M bmKc
'
BMi bQHp2U+QMbi p2+iQ`IBMi= ` iBM;b- p2+iQ`IBMi=
B7 U7(B) 44 yV &
7(B) 4 Rc
B7 UB = y ` iBM;b(B) = ` iBM;b(B @ R)V
7(B) 4 K tU7(B)- bQHp2U` iBM;b- 7- B @
B7 UB I ` iBM;bXbBx2UV @ R ` iBM;b(B) =
7(B) 4 K tU7(B)- bQHp2U` iBM;b- 7- B Y
'
`2im`M 7(B)c
'
'c
7- BMi BV &
RV Y RVc
` iBM;b(B Y R)V
RV Y RVc
2.1.23 Single Number
Given an array of integers, every element appears twice except for one. Find that single one.
Note: Your algorithm should have a linear runtime complexity. Could you implement it without using
extra memory?
38
1
ff G22i*Q/2- aBM;H2 LmK#2`
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi bBM;H2LmK#2`Up2+iQ`IBMi= MmKbV &
BMi t 4 yc
7Q` U miQ B , MmKbV &
t 4 Bc
'
`2im`M tc
'
'c
2
ff G22i*Q/2- aBM;H2 LmK#2`
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi bBM;H2LmK#2`Up2+iQ`IBMi= MmKbV &
`2im`M ++mKmH i2UMmKbX#2;BMUV- MmKbX2M/UV- y- #BintQ`IBMi=UVVc
'
'c
Single Number II,
2.1.24
2.1.24 Single Number II
Given an array of integers, every element appears three times except for one. Find that single one.
Note: Your algorithm should have a linear runtime complexity. Could you implement it without using
extra memory?
Single Number
1
1
bBx2Q7UBMiV
+QmMi(B)
+QmMi(bBx2Q7UBMiV) +QmMi(B)
39
2.1
2
QM2
irQ
QM2
1
irQ
mod 3
mod 3
QM2
1
ff G22i*Q/2- aBM;H2 LmK#2` AA
ff
R
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi bBM;H2LmK#2`Up2+iQ`IBMi= MmKbV &
+QMbi BMi q 4 bBx2Q7UBMiV
3c ff
BMi +QmMi(q)c ff +QmMi(B)
B
7BHHnMU +QmMi(y)- q- yVc
7Q` UBMi B 4 yc B I MmKbXbBx2UVc BYYV &
7Q` UBMi D 4 yc D I qc DYYV &
+QmMi(D) Y4 UMmKb(B) == DV Rc
+QmMi(D) W4 jc
'
'
BMi `2bmHi 4 yc
7Q` UBMi B 4 yc B I qc BYYV &
`2bmHi Y4 U+QmMi(B) II BVc
'
`2im`M `2bmHic
'
'c
2
ff G22i*Q/2- aBM;H2 LmK#2` AA
ff
k
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi bBM;H2LmK#2`Up2+iQ`IBMi= MmKbV &
BMi QM2 4 y- irQ 4 y- i?`22 4 yc
7Q` U miQ B , MmKbV &
irQ %4 UQM2 BVc
QM2 4 Bc
i?`22 4 UQM2 irQVc
QM2 4 i?`22c
irQ 4 i?`22c
'
'c
'
`2im`M QM2c
#Bi
R
40
Single Number,
2.1.23
2.2
ff
bi`m+i GBbiLQ/2 &
BMi p Hc
GBbiLQ/2 M2tic
GBbiLQ/2UBMi tV , p HUtV- M2tiUMmHHTi`V & '
'c
2.2.1 Add Two Numbers
You are given two linked lists representing two non-negative numbers. The digits are stored in reverse
order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
Input: Uk @= 9 @= jV Y U8 @= e @= 9V
Output: d @= y @= 3
Add Binary
3.4
ff G22i*Q/2- // hrQ LmK#2`b
ff
// "BM `v
ff
PUKYMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 //hrQLmK#2`bUGBbiLQ/2 HR- GBbiLQ/2 HkV &
GBbiLQ/2 /mKKvU@RVc ff
BMi + ``v 4 yc
GBbiLQ/2 T`2p 4 /mKKvc
7Q` UGBbiLQ/2 T 4 HR- T# 4 Hkc
T 54 MmHHTi` %% T# 54 MmHHTi`c
T 4 T 44 MmHHTi` \ MmHHTi` , T @=M2tiT# 4 T# 44 MmHHTi` \ MmHHTi` , T#@=M2tiT`2p 4 T`2p@=M2tiV &
+QMbi BMi B 4 T 44 MmHHTi` \ y , T @=p Hc
+QMbi BMi #B 4 T# 44 MmHHTi` \ y , T#@=p Hc
+QMbi BMi p Hm2 4 U B Y #B Y + ``vV W Ryc
+ ``v 4 U B Y #B Y + ``vV f Ryc
41
2.2
'c
'
T`2p@=M2ti 4 M2r GBbiLQ/2Up Hm2Vc ff
'
B7 U+ ``v = yV
T`2p@=M2ti 4 M2r GBbiLQ/2U+ ``vVc
`2im`M /mKKvXM2tic
Add Binary,
3.4
2.2.2 Reverse Linked List II
Reverse a linked list from position m to n. Do it in-place and in one-pass.
For example: Given R@=k@=j@=9@=8@=MmHHTi`, m = 2 and n = 4,
return R@=9@=j@=k@=8@=MmHHTi`.
Note: Given m, n satisfy the following condition: 1 m n length of list.
15
bug free
ff G22i*Q/2- _2p2`b2 GBMF2/ GBbi AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 `2p2`b2"2ir22MUGBbiLQ/2 ?2 /- BMi K- BMi MV &
GBbiLQ/2 /mKKvU@RVc
/mKKvXM2ti 4 ?2 /c
GBbiLQ/2 T`2p 4 /mKKvc
7Q` UBMi B 4 yc B I K@Rc YYBV
T`2p 4 T`2p@=M2tic
GBbiLQ/2 +QMbi ?2 /k 4 T`2pc
T`2p 4 ?2 /k@=M2tic
GBbiLQ/2 +m` 4 T`2p@=M2tic
7Q` UBMi B 4 Kc B I Mc YYBV &
T`2p@=M2ti 4 +m`@=M2tic
+m`@=M2ti 4 ?2 /k@=M2tic
?2 /k@=M2ti 4 +m`c ff
+m` 4 T`2p@=M2tic
'
42
'
'c
`2im`M /mKKvXM2tic
2.2.3 Partition List
Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater
than or equal to x.
You should preserve the original relative order of the nodes in each of the two partitions.
For example, Given R@=9@=j@=k@=8@=k and t 4 j, return R@=k@=k@=9@=j@=8.
ff G22i*Q/2- S `iBiBQM GBbi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 T `iBiBQMUGBbiLQ/2 ?2 /- BMi tV &
GBbiLQ/2 H27in/mKKvU@RVc ff
GBbiLQ/2 `B;?in/mKKvU@RVc ff
miQ H27in+m` 4 H27in/mKKvc
miQ `B;?in+m` 4 `B;?in/mKKvc
7Q` UGBbiLQ/2 +m` 4 ?2 /c +m`c +m` 4 +m`@=M2tiV &
B7 U+m`@=p H I tV &
H27in+m`@=M2ti 4 +m`c
H27in+m` 4 +m`c
' 2Hb2 &
`B;?in+m`@=M2ti 4 +m`c
`B;?in+m` 4 +m`c
'
'
H27in+m`@=M2ti 4 `B;?in/mKKvXM2tic
`B;?in+m`@=M2ti 4 MmHHTi`c
43
2.2
'
'c
`2im`M H27in/mKKvXM2tic
2.2.4 Remove Duplicates from Sorted List
Given a sorted linked list, delete all duplicates such that each element appear only once.
For example,
Given R@=R@=k, return R@=k.
Given R@=R@=k@=j@=j, return R@=k@=j.
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ GBbi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 /2H2i2.mTHB+ i2bUGBbiLQ/2 ?2 /V &
B7 U5?2 /V `2im`M ?2 /c
GBbiLQ/2 /mKKvU?2 /@=p H Y RVc ff
/mKKvXM2ti 4 ?2 /c
?2 /
`2+m`U /mKKv- ?2 /Vc
`2im`M /mKKvXM2tic
'
T`Bp i2,
bi iB+ pQB/ `2+m`UGBbiLQ/2 T`2p- GBbiLQ/2
B7 U+m` 44 MmHHTi`V `2im`Mc
'c
'
B7 UT`2p@=p H 44 +m`@=p HV & ff
T`2p@=M2ti 4 +m`@=M2tic
/2H2i2 +m`c
`2+m`UT`2p- T`2p@=M2tiVc
' 2Hb2 &
`2+m`UT`2p@=M2ti- +m`@=M2tiVc
'
+m`V &
?2 /
44
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ GBbi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 /2H2i2.mTHB+ i2bUGBbiLQ/2 ?2 /V &
B7 U?2 / 44 MmHHTi`V `2im`M MmHHTi`c
'c
'
7Q` UGBbiLQ/2 T`2p 4 ?2 /- +m` 4 ?2 /@=M2tic +m`c +m` 4 T`2p@=M2tiV &
B7 UT`2p@=p H 44 +m`@=p HV &
T`2p@=M2ti 4 +m`@=M2tic
/2H2i2 +m`c
' 2Hb2 &
T`2p 4 +m`c
'
'
`2im`M ?2 /c
Remove Duplicates from Sorted List II
2.2.5
2.2.5 Remove Duplicates from Sorted List II
Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers
from the original list.
For example,
Given R@=k@=j@=j@=9@=9@=8, return R@=k@=8.
Given R@=R@=R@=k@=j, return k@=j.
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ GBbi AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 /2H2i2.mTHB+ i2bUGBbiLQ/2 ?2 /V &
B7 U5?2 / %% 5?2 /@=M2tiV `2im`M ?2 /c
45
2.2
'c
'
GBbiLQ/2 T 4 ?2 /@=M2tic
B7 U?2 /@=p H 44 T@=p HV &
r?BH2 UT ?2 /@=p H 44 T@=p HV &
GBbiLQ/2 iKT 4 Tc
T 4 T@=M2tic
/2H2i2 iKTc
'
/2H2i2 ?2 /c
`2im`M /2H2i2.mTHB+ i2bUTVc
' 2Hb2 &
?2 /@=M2ti 4 /2H2i2.mTHB+ i2bU?2 /@=M2tiVc
`2im`M ?2 /c
'
ff G22i*Q/2- _2KQp2 .mTHB+ i2b 7`QK aQ`i2/ GBbi AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 /2H2i2.mTHB+ i2bUGBbiLQ/2 ?2 /V &
B7 U?2 / 44 MmHHTi`V `2im`M ?2 /c
'c
'
GBbiLQ/2 /mKKvUALhnJALVc ff
/mKKvXM2ti 4 ?2 /c
GBbiLQ/2 T`2p 4 /mKKv- +m` 4 ?2 /c
r?BH2 U+m` 54 MmHHTi`V &
#QQH /mTHB+ i2/ 4 7 Hb2c
r?BH2 U+m`@=M2ti 54 MmHHTi` +m`@=p H 44 +m`@=M2ti@=p HV &
/mTHB+ i2/ 4 i`m2c
GBbiLQ/2 i2KT 4 +m`c
+m` 4 +m`@=M2tic
/2H2i2 i2KTc
'
B7 U/mTHB+ i2/V & ff
GBbiLQ/2 i2KT 4 +m`c
+m` 4 +m`@=M2tic
/2H2i2 i2KTc
+QMiBMm2c
'
T`2p@=M2ti 4 +m`c
T`2p 4 T`2p@=M2tic
+m` 4 +m`@=M2tic
'
T`2p@=M2ti 4 +m`c
`2im`M /mKKvXM2tic
46
Remove Duplicates from Sorted List
2.2.4
2.2.6 Rotate List
Given a list, rotate the list to the right by k places, where k is non-negative.
For example: Given R@=k@=j@=9@=8@=MmHHTi` and F 4 k, return 9@=8@=R@=k@=j@=MmHHTi`.
len
len
len k
ff G22i*Q/2- _2KQp2 _Qi i2 GBbi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 `Qi i2_B;?iUGBbiLQ/2 ?2 /- BMi FV &
B7 U?2 / 44 MmHHTi` %% F 44 yV `2im`M ?2 /c
BMi H2M 4 Rc
GBbiLQ/2 T 4 ?2 /c
r?BH2 UT@=M2tiV & ff
H2MYYc
T 4 T@=M2tic
'
F 4 H2M @ F W H2Mc
'c
'
T@=M2ti 4 ?2 /c ff
7Q`UBMi bi2T 4 yc bi2T I Fc bi2TYYV &
T 4 T@=M2tic ff
'
?2 / 4 T@=M2tic ff
T@=M2ti 4 MmHHTi`c ff
`2im`M ?2 /c
k% = len
next
47
2.2
2.2.7 Remove Nth Node From End of List
Given a linked list, remove the nth node from the end of list and return its head.
For example, Given linked list: R@=k@=j@=9@=8, and n = 2.
After removing the second node from the end, the linked list becomes R@=k@=j@=8.
Note:
Given n will always be valid.
Try to do this in one pass.
p, q
ff G22i*Q/2- _2KQp2 Li? LQ/2 6`QK 1M/ Q7 GBbi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 `2KQp2Li?6`QK1M/UGBbiLQ/2 ?2 /- BMi MV &
GBbiLQ/2 /mKKv&@R- ?2 /'c
GBbiLQ/2 T 4 /mKKv- [ 4 /mKKvc
7Q` UBMi B 4 yc B I Mc BYYV
[ 4 [@=M2tic
'
'c
ff [
r?BH2U[@=M2tiV & ff
T 4 T@=M2tic
[ 4 [@=M2tic
'
GBbiLQ/2 iKT 4 T@=M2tic
T@=M2ti 4 T@=M2ti@=M2tic
/2H2i2 iKTc
`2im`M /mKKvXM2tic
2.2.8 Swap Nodes in Pairs
Given a linked list, swap every two adjacent nodes and return its head.
T@=M2ti
48
2
For example, Given R@=k@=j@=9, you should return the list as k@=R@=9@=j.
Your algorithm should use only constant space. You may not modify the values in the list, only nodes
itself can be changed.
ff G22i*Q/2- ar T LQ/2b BM S B`b
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 br TS B`bUGBbiLQ/2 ?2 /V &
B7 U?2 / 44 MmHHTi` %% ?2 /@=M2ti 44 MmHHTi`V `2im`M ?2 /c
GBbiLQ/2 /mKKvU@RVc
/mKKvXM2ti 4 ?2 /c
'c
'
7Q`UGBbiLQ/2 T`2p 4 /mKKv- +m` 4 T`2p@=M2ti- M2ti 4 +m`@=M2tic
M2tic
T`2p 4 +m`- +m` 4 +m`@=M2ti- M2ti 4 +m` \ +m`@=M2ti, MmHHTi`V &
T`2p@=M2ti 4 M2tic
+m`@=M2ti 4 M2ti@=M2tic
M2ti@=M2ti 4 +m`c
'
`2im`M /mKKvXM2tic
ff G22i*Q/2- ar T LQ/2b BM S B`b
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 br TS B`bUGBbiLQ/2 ?2 /V &
GBbiLQ/2 T 4 ?2 /c
r?BH2 UT T@=M2tiV &
br TUT@=p H- T@=M2ti@=p HVc
T 4 T@=M2ti@=M2tic
'
'c
'
`2im`M ?2 /c
Reverse Nodes in k-Group,
2.2.9
49
2.2
2.2.9 Reverse Nodes in k-Group
Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
You may not alter the values in the nodes, only nodes itself may be changed.
Only constant memory is allowed.
For example, Given this linked list: R@=k@=j@=9@=8
For k = 2, you should return: k@=R@=9@=j@=8
For k = 3, you should return: j@=k@=R@=9@=8
ff G22i*Q/2- _2p2`b2 LQ/2b BM F@:`QmT
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 `2p2`b2E:`QmTUGBbiLQ/2 ?2 /- BMi FV &
B7 U?2 / 44 MmHHTi` %% ?2 /@=M2ti 44 MmHHTi` %% F I kV
`2im`M ?2 /c
'c
'
GBbiLQ/2 M2tin;`QmT 4 ?2 /c
7Q` UBMi B 4 yc B I Fc YYBV &
B7 UM2tin;`QmTV
M2tin;`QmT 4 M2tin;`QmT@=M2tic
2Hb2
`2im`M ?2 /c
'
ff M2tin;`QmT Bb i?2 ?2 / Q7 M2ti ;`QmT
ff M2rnM2tin;`QmT Bb i?2 M2r ?2 / Q7 M2ti ;`QmT 7i2` `2p2`bBQM
GBbiLQ/2 M2rnM2tin;`QmT 4 `2p2`b2E:`QmTUM2tin;`QmT- FVc
GBbiLQ/2 T`2p 4 LlGG- +m` 4 ?2 /c
r?BH2 U+m` 54 M2tin;`QmTV &
GBbiLQ/2 M2ti 4 +m`@=M2tic
+m`@=M2ti 4 T`2p \ T`2p , M2rnM2tin;`QmTc
T`2p 4 +m`c
+m` 4 M2tic
'
`2im`M T`2pc ff T`2p rBHH #2 i?2 M2r ?2 / Q7 i?Bb ;`QmT
50
ff G22i*Q/2- _2p2`b2 LQ/2b BM F@:`QmT
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 `2p2`b2E:`QmTUGBbiLQ/2 ?2 /- BMi FV &
B7 U?2 / 44 MmHHTi` %% ?2 /@=M2ti 44 MmHHTi` %% F I kV `2im`M ?2 /c
GBbiLQ/2 /mKKvU@RVc
/mKKvXM2ti 4 ?2 /c
7Q`UGBbiLQ/2 T`2p 4 /mKKv- 2M/ 4 ?2 /c 2M/c 2M/ 4 T`2p@=M2tiV &
7Q` UBMi B 4 Rc B I F 2M/c BYYV
2M/ 4 2M/@=M2tic
B7 U2M/ 44 MmHHTi`V #`2 Fc ff
F
'
'
'c
T`2p 4 `2p2`b2UT`2p- T`2p@=M2ti- 2M/Vc
`2im`M /mKKvXM2tic
ff T`2p
7B`bi
- (#2;BM- 2M/)
MmHH
ff
R
GBbiLQ/2 `2p2`b2UGBbiLQ/2 T`2p- GBbiLQ/2 #2;BM- GBbiLQ/2 2M/V &
GBbiLQ/2 2M/nM2ti 4 2M/@=M2tic
7Q` UGBbiLQ/2 T 4 #2;BM- +m` 4 T@=M2ti- M2ti 4 +m`@=M2tic
+m` 54 2M/nM2tic
T 4 +m`- +m` 4 M2ti- M2ti 4 M2ti \ M2ti@=M2ti , MmHHTi`V &
+m`@=M2ti 4 Tc
'
#2;BM@=M2ti 4 2M/nM2tic
T`2p@=M2ti 4 2M/c
`2im`M #2;BMc
'
Swap Nodes in Pairs,
2.2.8
2.2.10 Copy List with Random Pointer
A linked list is given such that each node contains an additional random pointer which could point to
any node in the list or null.
Return a deep copy of the list.
51
2.2
ff G22i*Q/2- *QTv GBbi rBi? _ M/QK SQBMi2`
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
_ M/QKGBbiLQ/2 +QTv_ M/QKGBbiU_ M/QKGBbiLQ/2 ?2 /V &
7Q` U_ M/QKGBbiLQ/2 +m` 4 ?2 /c +m` 54 MmHHTi`c V &
_ M/QKGBbiLQ/2 MQ/2 4 M2r _ M/QKGBbiLQ/2U+m`@=H #2HVc
MQ/2@=M2ti 4 +m`@=M2tic
+m`@=M2ti 4 MQ/2c
+m` 4 MQ/2@=M2tic
'
7Q` U_ M/QKGBbiLQ/2 +m` 4 ?2 /c +m` 54 MmHHTi`c V &
B7 U+m`@=` M/QK 54 LlGGV
+m`@=M2ti@=` M/QK 4 +m`@=` M/QK@=M2tic
+m` 4 +m`@=M2ti@=M2tic
'
'
'c
ff
_ M/QKGBbiLQ/2 /mKKvU@RVc
7Q` U_ M/QKGBbiLQ/2 +m` 4 ?2 /+m` 54 MmHHTi`c V &
M2rn+m`@=M2ti 4 +m`@=M2tic
M2rn+m` 4 M2rn+m`@=M2tic
+m`@=M2ti 4 +m`@=M2ti@=M2tic
+m` 4 +m`@=M2tic
'
`2im`M /mKKvXM2tic
M2rn+m` 4 /mKKvc
2.2.11 Linked List Cycle
Given a linked list, determine if it has a cycle in it.
Follow up: Can you solve it without using extra space?
52
mMQ`/2`2/nK TIBMi- #QQH= pBbBi2/
O(n)
O(n)
O(N )
O(1)
http://leetcode.com/2010/09/detecting-loop-in-singly-linked-list.html
ffG22i*Q/2- GBMF2/ GBbi *v+H2
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH ? b*v+H2UGBbiLQ/2 ?2 /V &
ff
GBbiLQ/2 bHQr 4 ?2 /- 7 bi 4 ?2 /c
r?BH2 U7 bi 7 bi@=M2tiV &
bHQr 4 bHQr@=M2tic
7 bi 4 7 bi@=M2ti@=M2tic
B7 UbHQr 44 7 biV `2im`M i`m2c
'
`2im`M 7 Hb2c
'
'c
Linked List Cycle II,
2.2.12
2.2.12 Linked List Cycle II
Given a linked list, return the node where the cycle begins. If there is no cycle, return MmHH.
Follow up: Can you solve it without using extra space?
fast
slow
slow
s
slow
fast
2s
fast
fast
2s
s + nr
nr
n
n
(1 n)
r
53
2.2
x+a
nr = (n1)r + r = (n 1)r + L x
(n 1)r + (Lxa)
Lxa
?2 /
bHQrk
n1
ffG22i*Q/2- GBMF2/ GBbi *v+H2 AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 /2i2+i*v+H2UGBbiLQ/2 ?2 /V &
GBbiLQ/2 bHQr 4 ?2 /- 7 bi 4 ?2 /c
r?BH2 U7 bi 7 bi@=M2tiV &
bHQr 4 bHQr@=M2tic
7 bi 4 7 bi@=M2ti@=M2tic
B7 UbHQr 44 7 biV &
GBbiLQ/2 bHQrk 4 ?2 /c
r?BH2 UbHQrk 54 bHQrV &
bHQrk 4 bHQrk@=M2tic
bHQr 4 bHQr@=M2tic
'
`2im`M bHQrkc
'c
'
'
'
`2im`M MmHHTi`c
Linked List Cycle,
2.2.11
2.2.13 Reorder List
Given a singly linked list L : L0 L1 Ln1 Ln , reorder it to: L0 Ln L1
Ln1 L2 Ln2
You must do this in-place without altering the nodes values.
For example, Given &R-k-j-9', reorder it to &R-9-k-j'.
54
in-place
O(1)
reverse
ff G22i*Q/2- _2Q`/2` GBbi
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ `2Q`/2`GBbiUGBbiLQ/2 ?2 /V &
B7 U?2 / 44 MmHHTi` %% ?2 /@=M2ti 44 MmHHTi`V `2im`Mc
GBbiLQ/2 bHQr 4 ?2 /- 7 bi 4 ?2 /- T`2p 4 MmHHTi`c
r?BH2 U7 bi 7 bi@=M2tiV &
T`2p 4 bHQrc
bHQr 4 bHQr@=M2tic
7 bi 4 7 bi@=M2ti@=M2tic
'
T`2p@=M2ti 4 MmHHTi`c ff +mi i KB//H2
bHQr 4 `2p2`b2UbHQrVc
'
ff K2`;2 irQ HBbib
GBbiLQ/2 +m`` 4 ?2 /c
r?BH2 U+m``@=M2tiV &
GBbiLQ/2 iKT 4 +m``@=M2tic
+m``@=M2ti 4 bHQrc
bHQr 4 bHQr@=M2tic
+m``@=M2ti@=M2ti 4 iKTc
+m`` 4 iKTc
'
+m``@=M2ti 4 bHQrc
GBbiLQ/2 `2p2`b2UGBbiLQ/2 ?2 /V &
B7 U?2 / 44 MmHHTi` %% ?2 /@=M2ti 44 MmHHTi`V `2im`M ?2 /c
'c
'
GBbiLQ/2 T`2p 4 ?2 /c
7Q` UGBbiLQ/2 +m`` 4 ?2 /@=M2ti- M2ti 4 +m``@=M2tic +m``c
T`2p 4 +m``- +m`` 4 M2ti- M2ti 4 M2ti \ M2ti@=M2ti , MmHHTi`V &
+m``@=M2ti 4 T`2pc
'
?2 /@=M2ti 4 MmHHTi`c
`2im`M T`2pc
55
2.2
2.2.14 LRU Cache
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the
following operations: get and set.
;2iUF2vV - Get the value (will always be positive) of the key if the key exists in the cache, otherwise
return -1.
b2iUF2v- p Hm2V - Set or insert the value if the key is not already present. When the cache reached its
capacity, it should invalidate the least recently used item before inserting a new item.
(bi/,,HBbi)
(bi/,,mMQ`/2`2/nK T)
O(1)
hash
cache
size
capacity
ff G22i*Q/2- G_l * +?2
ff
PUHQ;MV
PUMV
+H bb G_l* +?2&
T`Bp i2,
bi`m+i * +?2LQ/2 &
BMi F2vc
BMi p Hm2c
* +?2LQ/2UBMi F- BMi pV ,F2vUFV- p Hm2UpV&'
'c
Tm#HB+,
G_l* +?2UBMi + T +BivV &
i?Bb@=+ T +Biv 4 + T +Bivc
'
hash
56
BMi ;2iUBMi F2vV &
B7 U+ +?2J TX7BM/UF2vV 44 + +?2J TX2M/UVV `2im`M @Rc
'
ff
K T
+ +?2GBbiXbTHB+2U+ +?2GBbiX#2;BMUV- + +?2GBbi- + +?2J T(F2v)Vc
+ +?2J T(F2v) 4 + +?2GBbiX#2;BMUVc
`2im`M + +?2J T(F2v)@=p Hm2c
pQB/ b2iUBMi F2v- BMi p Hm2V &
B7 U+ +?2J TX7BM/UF2vV 44 + +?2J TX2M/UVV &
B7 U+ +?2GBbiXbBx2UV 44 + T +BivV & ff
+ +?2J TX2` b2U+ +?2GBbiX# +FUVXF2vVc
+ +?2GBbiXTQTn# +FUVc
'
ff
K T
+ +?2GBbiXTmb?n7`QMiU* +?2LQ/2UF2v- p Hm2VVc
+ +?2J T(F2v) 4 + +?2GBbiX#2;BMUVc
' 2Hb2 &
ff
K T
+ +?2J T(F2v)@=p Hm2 4 p Hm2c
+ +?2GBbiXbTHB+2U+ +?2GBbiX#2;BMUV- + +?2GBbi- + +?2J T(F2v)Vc
+ +?2J T(F2v) 4 + +?2GBbiX#2;BMUVc
'
'
T`Bp i2,
HBbiI* +?2LQ/2= + +?2GBbic
mMQ`/2`2/nK TIBMi- HBbiI* +?2LQ/2=,,Bi2` iQ`= + +?2J Tc
BMi + T +Bivc
'c
3.1 Valid Palindrome
Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring
cases.
For example,
] K M- TH M- + M H, S M K ] is a palindrome.
]` +2 + `] is not a palindrome.
Note: Have you consider that the string might be empty? This is a good question to ask during an
interview.
For the purpose of this problem, we define empty string as valid palindrome.
ff G22i *Q/2- o HB/ S HBM/`QK2
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbS HBM/`QK2Ubi`BM; bV &
i` Mb7Q`KUbX#2;BMUV- bX2M/UV- bX#2;BMUV- ,,iQHQr2`Vc
miQ H27i 4 bX#2;BMUV- `B;?i 4 T`2pUbX2M/UVVc
r?BH2 UH27i I `B;?iV &
B7 U5,,Bb HMmKU H27iVV YYH27ic
2Hb2 B7 U5,,Bb HMmKU `B;?iVV @@`B;?ic
2Hb2 B7 U H27i 54 `B;?iV `2im`M 7 Hb2c
2Hb2 & H27iYY- `B;?i@@c '
'
`2im`M i`m2c
'
'c
57
58
Palindrome Number,
15.2
3.2 Implement strStr()
Implement strStr().
Returns a pointer to the first occurrence of needle in haystack, or null if needle is not part of haystack.
Rabin-Karp
O(m n)
KMP
Boyer-Mooer
BUG
ff G22i*Q/2- AKTH2K2Mi bi`ai`UV
ff
PUL JV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi bi`ai`U+QMbi bi`BM; ? vbi +F- +QMbi bi`BM; M22/H2V &
B7 UM22/H2X2KTivUVV `2im`M yc
'c
'
+QMbi BMi L 4 ? vbi +FXbBx2UV @ M22/H2XbBx2UV Y Rc
7Q` UBMi B 4 yc B I Lc BYYV &
BMi D 4 Bc
BMi F 4 yc
r?BH2 UD I ? vbi +FXbBx2UV F I M22/H2XbBx2UV ? vbi +F(D) 44 M22/H2(F)V &
DYYc
FYYc
'
B7 UF 44 M22/H2XbBx2UVV `2im`M Bc
'
`2im`M @Rc
KMP
ff G22i*Q/2- AKTH2K2Mi bi`ai`UV
ff EJS
PULYJV
PUJV
+H bb aQHmiBQM &
Tm#HB+,
BMi bi`ai`U+QMbi bi`BM; ? vbi +F- +QMbi bi`BM; M22/H2V &
`2im`M FKTU? vbi +FX+nbi`UV- M22/H2X+nbi`UVVc
'
59
3.2 Implement strStr()
T`Bp i2,
f
!#`B27
M2ti
!T ` K(BM) T ii2`M
!T ` K(Qmi) M2ti M2ti
!`2im`M
f
bi iB+ pQB/ +QKTmi2nT`27BtU+QMbi +? `
BMi Bc
BMi D 4 @Rc
+QMbi BMi K 4 bi`H2MUT ii2`MVc
T ii2`M- BMi M2ti()V &
M2ti(y) 4 Dc
7Q` UB 4 Rc B I Kc BYYV &
r?BH2 UD = @R T ii2`M(D Y R) 54 T ii2`M(B)V D 4 M2ti(D)c
'
f
'
B7 UT ii2`M(B) 44 T ii2`M(D Y R)V DYYc
M2ti(B) 4 Dc
!#`B27 EJS
!T ` K(BM) i2ti
!T ` K(BM) T ii2`M
!`2im`M
@R
f
bi iB+ BMi FKTU+QMbi +? ` i2ti- +QMbi +? ` T ii2`MV &
BMi Bc
BMi D 4 @Rc
+QMbi BMi M 4 bi`H2MUi2tiVc
+QMbi BMi K 4 bi`H2MUT ii2`MVc
B7 UM 44 y K 44 yV `2im`M yc f ]]-]] f
B7 UK 44 yV `2im`M yc f ] ]-]] f
BMi M2ti 4 UBMi VK HHQ+UbBx2Q7UBMiV
KVc
+QKTmi2nT`27BtUT ii2`M- M2tiVc
7Q` UB 4 yc B I Mc BYYV &
r?BH2 UD = @R T ii2`M(D Y R) 54 i2ti(B)V D 4 M2ti(D)c
'
'
B7 Ui2ti(B) 44 T ii2`M(D Y R)V DYYc
B7 UD 44 K @ RV &
7`22UM2tiVc
`2im`M B@Dc
'
7`22UM2tiVc
`2im`M @Rc
60
'c
String to Integer (atoi)
3.3
3.3 String to Integer (atoi)
Implement iQB to convert a string to an integer.
Hint: Carefully consider all possible input cases. If you want a challenge, please do not see below and
ask yourself what are the possible input cases.
Notes: It is intended for this problem to be specified vaguely (ie, no given input specs). You are responsible to gather all the input requirements up front.
Requirements for atoi:
The function first discards as many whitespace characters as necessary until the first non-whitespace
character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by
as many numerical digits as possible, and interprets them as a numerical value.
The string can contain additional characters after those that form the integral number, which are ignored
and have no effect on the behavior of this function.
If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such
sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.
If no valid conversion could be performed, a zero value is returned. If the correct value is out of the
range of representable values, ALhnJs UkR9d93je9dV or ALhnJAL U@kR9d93je93V is returned.
1.
-3924x8fc
2.
++c, ++1
3.
2147483648
+ 413,
ff G22i*Q/2- ai`BM; iQ AMi2;2` U iQBV
ff
PUMV
PURV
+H bb aQHmiBQM &
61
3.4 Add Binary
Tm#HB+,
BMi KviQBU+QMbi bi`BM; bi`V &
BMi MmK 4 yc
BMi bB;M 4 Rc
+QMbi BMi M 4 bi`XH2M;i?UVc
BMi B 4 yc
r?BH2 Ubi`(B) 44 ^ ^ B I MV BYYc
B7 Ubi`(B) 44 ^Y^V &
BYYc
' 2Hb2 B7 Ubi`(B) 44 ^@^V &
bB;M 4 @Rc
BYYc
'
'c
'
7Q` Uc B I Mc BYYV &
B7 Ubi`(B) I ^y^ %% bi`(B) = ^N^V
#`2 Fc
B7 UMmK = ALhnJs f Ry %%
UMmK 44 ALhnJs f Ry
Ubi`(B) @ ^y^V = ALhnJs W RyVV &
`2im`M bB;M 44 @R \ ALhnJAL , ALhnJsc
'
MmK 4 MmK
Ry Y bi`(B) @ ^y^c
'
`2im`M MmK
bB;Mc
Implement strStr()
3.2
3.4 Add Binary
Given two binary strings, return their sum (also a binary string).
For example,
4 ]RR]
# 4 ]R]
Return ]Ryy].
62
ffG22i*Q/2- // "BM `v
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; //"BM `vUbi`BM; - bi`BM; #V &
bi`BM; `2bmHic
+QMbi bBx2ni M 4 XbBx2UV = #XbBx2UV \ XbBx2UV , #XbBx2UVc
`2p2`b2U X#2;BMUV- X2M/UVVc
`2p2`b2U#X#2;BMUV- #X2M/UVVc
BMi + ``v 4 yc
7Q` UbBx2ni B 4 yc B I Mc BYYV &
+QMbi BMi B 4 B I XbBx2UV \ (B) @ ^y^ , yc
+QMbi BMi #B 4 B I #XbBx2UV \ #(B) @ ^y^ , yc
+QMbi BMi p H 4 U B Y #B Y + ``vV W kc
+ ``v 4 U B Y #B Y + ``vV f kc
`2bmHiXBMb2`iU`2bmHiX#2;BMUV- p H Y ^y^Vc
'
B7 U+ ``v 44 RV &
`2bmHiXBMb2`iU`2bmHiX#2;BMUV- ^R^Vc
'
`2im`M `2bmHic
'
'c
Add Two Numbers,
2.2.1
3.5 Longest Palindromic Substring
Given a string S, find the longest palindromic substring in S. You may assume that the maximum length
of S is 1000, and there exists one unique longest palindromic substring.
O(n2 )
O(n2 )
7(B)(D)
[i,j]
7(B)(D) 4 B7 UB 44 DV a(B)
B7 Ua(B) 44 a(D) 7(BYR)(D@R) 44 a(BYR)(D@R)V a(B)(D)
2Hb2 K tU7(BYR)(D@R)- 7(B)(D@R)- 7(BYR)(D)V
63
3.5 Longest Palindromic Substring
O(n2 )
f (i, j) =
7UB-DV
[i,j]
true
,i = j
S[i] = S[j]
S[i] = S[j] and f (i + 1, j 1)
Manacher s Algorithm,
O(n)
,j = i + 1
,j > i + 1
http://leetcode.com/2011/11/longest-
palindromic-substring-part-ii.html
ff G22i*Q/2- GQM;2bi S HBM/`QKB+ am#bi`BM;
ff
ff
PUM kV
PUM kV
ivT2/27 bi`BM;,,+QMbinBi2` iQ` Ai2` iQ`c
M K2bT +2 bi/ &
i2KTH i2I=
bi`m+i ? b?IT B`IAi2` iQ`- Ai2` iQ`== &
bBx2ni QT2` iQ`UVUT B`IAi2` iQ`- Ai2` iQ`= +QMbi TV +QMbi &
`2im`M UUbBx2niV U TX7B`biVV UUbBx2niV U TXb2+QM/VVc
'
'c
'
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; HQM;2biS HBM/`QK2Ubi`BM; +QMbi bV &
+ +?2X+H2 `UVc
`2im`M + +?2/GQM;2biS HBM/`QK2UbX#2;BMUV- bX2M/UVVc
'
T`Bp i2,
mMQ`/2`2/nK TIT B`IAi2` iQ`- Ai2` iQ`=- bi`BM;= + +?2c
bi`BM; HQM;2biS HBM/`QK2UAi2` iQ` 7B`bi- Ai2` iQ` H biV &
bBx2ni H2M;i? 4 /Bbi M+2U7B`bi- H biVc
B7 UH2M;i? I kV `2im`M bi`BM;U7B`bi- H biVc
miQ b 4 + +?2/GQM;2biS HBM/`QK2UM2tiU7B`biV- T`2pUH biVVc
B7 UbXH2M;i?UV 44 H2M;i? @ k
`2im`M bi`BM;U7B`bi- H biVc
7B`bi 44
T`2pUH biVV
miQ bR 4 + +?2/GQM;2biS HBM/`QK2UM2tiU7B`biV- H biVc
miQ bk 4 + +?2/GQM;2biS HBM/`QK2U7B`bi- T`2pUH biVVc
ff `2im`M K tUb- bR- bkV
B7 UbXbBx2UV = bRXbBx2UVV `2im`M bXbBx2UV = bkXbBx2UV \ b , bkc
64
'
2Hb2 `2im`M bRXbBx2UV = bkXbBx2UV \ bR , bkc
bi`BM; + +?2/GQM;2biS HBM/`QK2UAi2` iQ` 7B`bi- Ai2` iQ` H biV &
miQ F2v 4 K F2nT B`U7B`bi- H biVc
miQ TQb 4 + +?2X7BM/UF2vVc
'c
'
B7 UTQb 54 + +?2X2M/UVV `2im`M TQb@=b2+QM/c
2Hb2 `2im`M + +?2(F2v) 4 HQM;2biS HBM/`QK2U7B`bi- H biVc
ff G22i*Q/2- GQM;2bi S HBM/`QKB+ am#bi`BM;
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; HQM;2biS HBM/`QK2U+QMbi bi`BM; bV &
+QMbi BMi M 4 bXbBx2UVc
#QQH 7(M)(M)c
7BHHnMU 7(y)(y)- M
M- 7 Hb2Vc
ff
p2+iQ`
ffp2+iQ`Ip2+iQ`I#QQH= = 7UM- p2+iQ`I#QQH=UM- 7 Hb2VVc
bBx2ni K tnH2M 4 R- bi `i 4 yc ff
'c
'
7Q` UbBx2ni B 4 yc B I bXbBx2UVc BYYV
7(B)(B) 4 i`m2c
7Q` UbBx2ni D 4 yc D I Bc DYYV &
7(D)(B) 4 Ub(D) 44 b(B) UB
B7 U7(D)(B) K tnH2M I UB @
K tnH2M 4 B @ D Y Rc
bi `i 4 Dc
'
'
'
`2im`M bXbm#bi`Ubi `i- K tnH2MVc
&
ff (D- B)
@ D I k %% 7(D Y R)(B @ R)VVc
D Y RVV &
Manacher s Algorithm
ff G22i*Q/2- GQM;2bi S HBM/`QKB+ am#bi`BM;
ff J M +?2` b H;Q`Bi?K
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
ff h` Mb7Q`K a BMiQ hX
ff 6Q` 2t KTH2- a 4 ] ## ]- h 4 ] O O#O#O O0]X
ff M/ 0 bB;Mb `2 b2MiBM2Hb TT2M/2/ iQ 2 +? 2M/ iQ pQB/ #QmM/b +?2+FBM;
bi`BM; T`2S`Q+2bbU+QMbi bi`BM; bV &
BMi M 4 bXH2M;i?UVc
65
3.5 Longest Palindromic Substring
B7 UM 44 yV `2im`M ] 0]c
bi`BM; `2i 4 ] ]c
7Q` UBMi B 4 yc B I Mc BYYV `2i Y4 ]O] Y bXbm#bi`UB- RVc
'
`2i Y4 ]O0]c
`2im`M `2ic
bi`BM; HQM;2biS HBM/`QK2Ubi`BM; bV &
bi`BM; h 4 T`2S`Q+2bbUbVc
+QMbi BMi M 4 hXH2M;i?UVc
ff
h(B)
f
ff
S(B)
BMi S(M)c
BMi * 4 y- _ 4 yc
h(B)
7Q` UBMi B 4 Rc B I M @ Rc BYYV &
BMi BnKB``Q` 4 k
* @ Bc ff 2[m Hb iQ B^ 4 * @ UB@*V
S(B) 4 U_ = BV \ KBMU_ @ B- S(BnKB``Q`)V , yc
ff ii2KTi iQ 2tT M/ T HBM/`QK2 +2Mi2`2/ i B
r?BH2 Uh(B Y R Y S(B)) 44 h(B @ R @ S(B))V
S(B)YYc
'
ff A7 T HBM/`QK2 +2Mi2`2/ i B 2tT M/ T bi _ff /Dmbi +2Mi2` # b2/ QM 2tT M/2/ T HBM/`QK2X
B7 UB Y S(B) = _V &
* 4 Bc
_ 4 B Y S(B)c
'
ff 6BM/ i?2 K tBKmK 2H2K2Mi BM SX
BMi K tnH2M 4 yc
BMi +2Mi2`nBM/2t 4 yc
7Q` UBMi B 4 Rc B I M @ Rc BYYV &
B7 US(B) = K tnH2MV &
K tnH2M 4 S(B)c
+2Mi2`nBM/2t 4 Bc
'
'
'c
'
`2im`M bXbm#bi`UU+2Mi2`nBM/2t @ R @ K tnH2MV f k- K tnH2MVc
66
3.6 Regular Expression Matching
Implement regular expression matching with support for ^X^ and ^ ^.
^X^ Matches any single character. ^ ^ Matches zero or more of the preceding element.
The matching should cover the entire input string (not partial).
The function prototype should be:
#QQH BbJ i+?U+QMbi +? `
b- +QMbi +? `
TV
Some examples:
BbJ i+?U] ]-] ]V 7 Hb2
BbJ i+?U] ]-] ]V i`m2
BbJ i+?U] ]-] ]V 7 Hb2
BbJ i+?U] ]- ] ]V i`m2
BbJ i+?U] ]- ]X ]V i`m2
BbJ i+?U] #]- ]X ]V i`m2
BbJ i+?U] #]- ]+ #]V i`m2
ff G22i*Q/2- _2;mH ` 1tT`2bbBQM J i+?BM;
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbJ i+?U+QMbi bi`BM; b- +QMbi bi`BM; TV &
`2im`M BbJ i+?UbX+nbi`UV- TX+nbi`UVVc
'
T`Bp i2,
#QQH BbJ i+?U+QMbi +? ` b- +QMbi +? ` TV &
B7 U T 44 ^$y^V `2im`M b 44 ^$y^c
ff M2ti +? ` Bb MQi ^ ^- i?2M Kmbi K i+? +m``2Mi +? ` +i2`
B7 U UT Y RV 54 ^ ^V &
B7 U T 44 b %% U T 44 ^X^ b 54 ^$y^VV
`2im`M BbJ i+?Ub Y R- T Y RVc
2Hb2
`2im`M 7 Hb2c
' 2Hb2 & ff M2ti +? ` Bb ^ ^
r?BH2 U T 44 b %% U T 44 ^X^ b 54 ^$y^VV &
B7 UBbJ i+?Ub- T Y kVV
`2im`M i`m2c
bYYc
'
`2im`M BbJ i+?Ub- T Y kVc
67
3.7 Wildcard Matching
'c
'
'
Wildcard Matching,
3.7
3.7 Wildcard Matching
Implement wildcard pattern matching with support for ^\^ and ^ ^.
^\^ Matches any single character. ^ ^ Matches any sequence of characters (including the empty sequence).
The matching should cover the entire input string (not partial).
The function prototype should be:
#QQH BbJ i+?U+QMbi +? `
b- +QMbi +? `
TV
Some examples:
BbJ i+?U] ]-] ]V 7 Hb2
BbJ i+?U] ]-] ]V i`m2
BbJ i+?U] ]-] ]V 7 Hb2
BbJ i+?U] ]- ] ]V i`m2
BbJ i+?U] ]- ] ]V i`m2
BbJ i+?U] #]- ]\ ]V i`m2
BbJ i+?U] #]- ]+ #]V 7 Hb2
^ ^
^ ^
bYY
ff G22i*Q/2- qBH/+ `/ J i+?BM;
ff
ff
PUM5 K5V
+H bb aQHmiBQM &
Tm#HB+,
PUMV
^ ^
68
#QQH BbJ i+?U+QMbi bi`BM; b- +QMbi bi`BM; TV &
`2im`M BbJ i+?UbX+nbi`UV- TX+nbi`UVVc
'
T`Bp i2,
#QQH BbJ i+?U+QMbi +? ` b- +QMbi +? ` TV &
B7 U T 44 ^ ^V &
r?BH2 U T 44 ^ ^V YYTc ffbFBT +QMiBMmQmb ^ ^
B7 U T 44 ^$y^V `2im`M i`m2c
r?BH2 U b 54 ^$y^ 5BbJ i+?Ub- TVV YYbc
'c
'
`2im`M
'
2Hb2 B7 U T
2Hb2 B7 U T
2Hb2 `2im`M
b 54 ^$y^c
44 ^$y^ %% b 44 ^$y^V `2im`M T 44 bc
44 b %% T 44 ^\^V `2im`M BbJ i+?UYYb- YYTVc
7 Hb2c
ff G22i*Q/2- qBH/+ `/ J i+?BM;
ff
PUM KV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbJ i+?U+QMbi bi`BM; b- +QMbi bi`BM; TV &
`2im`M BbJ i+?UbX+nbi`UV- TX+nbi`UVVc
'
T`Bp i2,
#QQH BbJ i+?U+QMbi +? ` b- +QMbi +? ` TV &
#QQH bi ` 4 7 Hb2c
+QMbi +? ` bi`- Ti`c
7Q` Ubi` 4 b- Ti` 4 Tc bi` 54 ^$y^c bi`YY- Ti`YYV &
brBi+? U Ti`V &
+ b2 ^\^,
#`2 Fc
+ b2 ^ ^,
bi ` 4 i`m2c
b 4 bi`- T 4 Ti`c
r?BH2 U T 44 ^ ^V TYYc ffbFBT +QMiBMmQmb ^ ^
B7 U T 44 ^$y^V `2im`M i`m2c
bi` 4 b @ Rc
Ti` 4 T @ Rc
#`2 Fc
/27 mHi,
B7 U bi` 54 Ti`V &
ff
^ ^
B7 U5bi `V `2im`M 7 Hb2c
bYYc
bi` 4 b @ Rc
Ti` 4 T @ Rc
'
'
'
69
3.8 Longest Common Prefix
'c
'
r?BH2 U Ti` 44 ^ ^V Ti`YYc
`2im`M U Ti` 44 ^$y^Vc
Regular Expression Matching,
3.6
3.8 Longest Common Prefix
Write a function to find the longest common prefix string amongst an array of strings.
ff G22i*Q/2- GQM;2bi *QKKQM S`27Bt
ff
y
ff
PUMRYMkYXXXV
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfx?Qm/BiivV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; HQM;2bi*QKKQMS`27BtUp2+iQ`Ibi`BM;= bi`bV &
B7 Ubi`bX2KTivUVV `2im`M ]]c
'c
'
7Q` UBMi B/t 4 yc B/t I bi`b(y)XbBx2UVc YYB/tV & ff
7Q` UBMi B 4 Rc B I bi`bXbBx2UVc YYBV &
B7 Ubi`b(B)(B/t) 54 bi`b(y)(B/t)V `2im`M bi`b(y)Xbm#bi`Uy-B/tVc
'
'
`2im`M bi`b(y)c
ff G22i*Q/2- GQM;2bi *QKKQM S`27Bt
ff
y
ff
ff
PUMRYMkYXXXV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; HQM;2bi*QKKQMS`27BtUp2+iQ`Ibi`BM;= bi`bV &
70
3
B7 Ubi`bX2KTivUVV `2im`M ]]c
BMi `B;?inKQbi 4 bi`b(y)XbBx2UV @ Rc
7Q` UbBx2ni B 4 Rc B I bi`bXbBx2UVc BYYV
7Q` UBMi D 4 yc D I4 `B;?inKQbic DYYV
B7 Ubi`b(B)(D) 54 bi`b(y)(D)V ff
`B;?inKQbi 4 D @ Rc
'
'c
bi`BM;,,()
`2im`M bi`b(y)Xbm#bi`Uy- `B;?inKQbi Y RVc
3.9 Valid Number
Validate if a given string is numeric.
Some examples:
]y] 4= i`m2
] yXR ] 4= i`m2
] #+] 4= 7 Hb2
]R ] 4= 7 Hb2
]k2Ry] 4= i`m2
Note: It is intended for the problem statement to be ambiguous. You should gather all requirements up
front before implementing one.
bi`iQ/UV
ff G22i*Q/2- o HB/ LmK#2`
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHm M;QM;V
ff 7BMBi2 miQK i
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbLmK#2`U+QMbi bi`BM; bV &
2MmK AMTmihvT2 &
ALoGA.ff y
aS*1ff R
PUMV
71
3.9 Valid Number
aA:L.A:Ah.Ph1sSPL1LhLlJnALSlha
ff
ff
ff
ff
ff
k
j
9
8
e
'c
+QMbi BMi i` MbBiBQMh #H2()(LlJnALSlha) 4 &
@R- y- j- R- k- @R- ff M2ti bi i2b 7Q` bi i2 y
@R- 3- @R- R- 9- 8ff M2ti bi i2b 7Q` bi i2 R
@R- @R- @R- 9- @R- @Rff M2ti bi i2b 7Q` bi i2 k
@R- @R- @R- R- k- @Rff M2ti bi i2b 7Q` bi i2 j
@R- 3- @R- 9- @R- 8ff M2ti bi i2b 7Q` bi i2 9
@R- @R- e- d- @R- @Rff M2ti bi i2b 7Q` bi i2 8
@R- @R- @R- d- @R- @Rff M2ti bi i2b 7Q` bi i2 e
@R- 3- @R- d- @R- @Rff M2ti bi i2b 7Q` bi i2 d
@R- 3- @R- @R- @R- @Rff M2ti bi i2b 7Q` bi i2 3
'c
BMi bi i2 4 yc
7Q` U miQ +? , bV &
AMTmihvT2 BMTmihvT2 4 ALoGA.c
B7 UBbbT +2U+?VV
BMTmihvT2 4 aS*1c
2Hb2 B7 U+? 44 ^Y^ %% +? 44 ^@^V
BMTmihvT2 4 aA:Lc
2Hb2 B7 UBb/B;BiU+?VV
BMTmihvT2 4 .A:Ahc
2Hb2 B7 U+? 44 ^X^V
BMTmihvT2 4 .Phc
2Hb2 B7 U+? 44 ^2^ %% +? 44 ^1^V
BMTmihvT2 4 1sSPL1Lhc
ff :2i M2ti bi i2 7`QK +m``2Mi bi i2 M/ BMTmi bvK#QH
bi i2 4 i` MbBiBQMh #H2(bi i2)(BMTmihvT2)c
ff AMp HB/ BMTmi
B7 Ubi i2 44 @RV `2im`M 7 Hb2c
'
ff A7 i?2 +m``2Mi bi i2 #2HQM;b iQ QM2 Q7 i?2 ++2TiBM; U7BM HV bi i2bff i?2M i?2 MmK#2` Bb p HB/
`2im`M bi i2 44 R %% bi i2 44 9 %% bi i2 44 d %% bi i2 44 3c
'c
'
strtod()
ff G22i*Q/2- o HB/ LmK#2`
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHB M+?2M;xDmV
ff
bi`iQ/UV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbLmK#2` U+QMbi bi`BM; bV &
72
`2im`M BbLmK#2`UbX+nbi`UVVc
'
T`Bp i2,
#QQH BbLmK#2` U+? ` +QMbi bV &
+? ` 2M/Ti`c
bi`iQ/ Ub- 2M/Ti`Vc
B7 U2M/Ti` 44 bV `2im`M 7 Hb2c
7Q` Uc 2M/Ti`c YY2M/Ti`V
B7 U5BbbT +2 U 2M/Ti`VV `2im`M 7 Hb2c
'
'c
`2im`M i`m2c
3.10 Integer to Roman
Given an integer, convert it to a roman numeral.
Input is guaranteed to be within the range from 1 to 3999.
ff G22i*Q/2- AMi2;2` iQ _QK M
ff
PUMmKV
PURV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; BMihQ_QK MUBMi MmKV &
+QMbi BMi ` /Bt() 4 &Ryyy- Nyy- 8yy- 9yy- Ryy- Ny8y- 9y- Ry- N- 8- 9- R'c
+QMbi bi`BM; bvK#QH() 4 &]J]- ]*J]- ].]- ]*.]- ]*]- ]s*]]G]- ]sG]- ]s]- ]As]- ]o]- ]Ao]- ]A]'c
bi`BM; `QK Mc
7Q` UbBx2ni B 4 yc MmK = yc YYBV &
BMi +QmMi 4 MmK f ` /Bt(B)c
MmK W4 ` /Bt(B)c
7Q` Uc +QmMi = yc @@+QmMiV `QK M Y4 bvK#QH(B)c
73
3.11 Roman to Integer
'c
'
'
`2im`M `QK Mc
Roman to Integer,
3.11
3.11 Roman to Integer
Given a roman numeral, convert it to an integer.
Input is guaranteed to be within the range from 1 to 3999.
Ao 4 8 R
oA 4 8 Y R- AA4RYR
ff G22i*Q/2- _QK M iQ AMi2;2`
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMHBM2 BMi K TU+QMbi +? ` +V &
brBi+? U+V &
+ b2 ^A^, `2im`M Rc
+ b2 ^o^, `2im`M 8c
+ b2 ^s^, `2im`M Ryc
+ b2 ^G^, `2im`M 8yc
+ b2 ^*^, `2im`M Ryyc
+ b2 ^.^, `2im`M 8yyc
+ b2 ^J^, `2im`M Ryyyc
/27 mHi, `2im`M yc
'
'
BMi `QK MhQAMiU+QMbi bi`BM; bV &
BMi `2bmHi 4 yc
7Q` UbBx2ni B 4 yc B I bXbBx2UVc BYYV &
B7 UB = y K TUb(B)V = K TUb(B @ R)VV &
`2bmHi Y4 UK TUb(B)V @ k
K TUb(B @ R)VVc
' 2Hb2 &
74
'
'c
'
`2bmHi Y4 K TUb(B)Vc
'
`2im`M `2bmHic
Integer to Roman,
3.10
3.12 Count and Say
The count-and-say sequence is the sequence of integers beginning as follows:
R- RR- kR- RkRR- RRRkkR- XXX
R is read off as ]QM2 R] or RR.
RR is read off as ]irQ Rb] or kR.
kR is read off as ]QM2 k], then ]QM2 R] or RkRR.
Given an integer n, generate the nth sequence.
Note: The sequence of integers will be represented as a string.
ff G22i*Q/2- *QmMi M/ a v
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHB M+?2M;xDmV
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; +QmMiM/a vUBMi MV &
bi`BM; bU]R]Vc
r?BH2 U@@MV
b 4 ;2iL2tiUbVc
'
`2im`M bc
bi`BM; ;2iL2tiU+QMbi bi`BM; bV &
bi`BM;bi`2 K bbc
75
3.13 Anagrams
7Q` U miQ B 4 bX#2;BMUVc B 54 bX2M/UVc V &
miQ D 4 7BM/nB7UB- bX2M/UV- #BM/RbiUMQin2[m HniQI+? `=UVbb II /Bbi M+2UB- DV II Bc
B 4 Dc
'
'
'c
BVVc
`2im`M bbXbi`UVc
3.13 Anagrams
Given an array of strings, return all groups of strings that are anagrams.
Note: All inputs will be in lower-case.
]/Q`KBiQ`v]
Anagram
]/B`iv `QQK]
]i2 ]
]2 i]
anagrams
ff G22i*Q/2- M ;` Kb
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ibi`BM;= M ;` KbUp2+iQ`Ibi`BM;= bi`bV &
mMQ`/2`2/nK TIbi`BM;- p2+iQ`Ibi`BM;= = ;`QmTc
7Q` U+QMbi miQ b , bi`bV &
bi`BM; F2v 4 bc
bQ`iUF2vX#2;BMUV- F2vX2M/UVVc
;`QmT(F2v)XTmb?n# +FUbVc
'
p2+iQ`Ibi`BM;= `2bmHic
7Q` U miQ Bi 4 ;`QmTX+#2;BMUVc Bi 54 ;`QmTX+2M/UVc BiYYV &
B7 UBi@=b2+QM/XbBx2UV = RV
`2bmHiXBMb2`iU`2bmHiX2M/UV- Bi@=b2+QM/X#2;BMUV- Bi@=b2+QM/X2M/UVVc
'
76
'
'c
`2im`M `2bmHic
3.14 Simplify Path
Given an absolute path for a file (Unix-style), simplify it.
For example,
path = ]f?QK2f], => ]f?QK2]
path = ]f fXf#fXXfXXf+f], => ]f+]
Corner Cases:
Did you consider the case where path = ]fXXf]? In this case, you should return ]f].
Another corner case is the path might contain multiple slashes ^f^ together, such as ]f?QK2ff7QQf].
In this case, you should ignore redundant slashes and return ]f?QK2f7QQ].
ff G22i*Q/2- aBKTHB7v S i?
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; bBKTHB7vS i?U+QMbi bi`BM; T i?V &
p2+iQ`Ibi`BM;= /B`bc ff
7Q` U miQ B 4 T i?X#2;BMUVc B 54 T i?X2M/UVcV &
YYBc
miQ D 4 7BM/UB- T i?X2M/UV- ^f^Vc
miQ /B` 4 bi`BM;UB- DVc
B7 U5/B`X2KTivUV /B` 54 ]X]V &ff
B7 U/B` 44 ]XX]V &
B7 U5/B`bX2KTivUVV
/B`bXTQTn# +FUVc
^fff^
/B`
3.15 Length of Last Word
'
77
' 2Hb2
/B`bXTmb?n# +FU/B`Vc
B 4 Dc
'
bi`BM;bi`2 K Qmic
B7 U/B`bX2KTivUVV &
Qmi II ]f]c
' 2Hb2 &
7Q` U miQ /B` , /B`bV
Qmi II ^f^ II /B`c
'
'
'c
`2im`M QmiXbi`UVc
3.15 Length of Last Word
Given a string s consists of upper/lower-case alphabets and empty space characters ^ ^, return the length
of last word in the string.
If the last word does not exist, return 0.
Note: A word is defined as a character sequence consists of non-space characters only.
For example, Given b 4 ]>2HHQ qQ`H/], return 5.
STL
ff G22i*Q/2- G2M;i? Q7 G bi qQ`/
ff
ahG
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi H2M;i?P7G biqQ`/U+QMbi bi`BM; bV &
miQ 7B`bi 4 7BM/nB7UbX`#2;BMUV- bX`2M/UV- ,,Bb HT? Vc
miQ H bi 4 7BM/nB7nMQiU7B`bi- bX`2M/UV- ,,Bb HT? Vc
78
'c
'
`2im`M /Bbi M+2U7B`bi- H biVc
ff G22i*Q/2- G2M;i? Q7 G bi qQ`/
ff
rQ`/
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi H2M;i?P7G biqQ`/U+QMbi bi`BM; bV &
`2im`M H2M;i?P7G biqQ`/UbX+nbi`UVVc
'
T`Bp i2,
BMi H2M;i?P7G biqQ`/U+QMbi +? ` bV &
BMi H2M 4 yc
r?BH2 U bV &
B7 U bYY 54 ^ ^V
YYH2Mc
2Hb2 B7 U b b 54 ^ ^V
H2M 4 yc
'
`2im`M H2Mc
'
'c
4.1
4.1.1 Valid Parentheses
Given a string containing just the characters ^U^- ^V^- ^&^- ^'^- ^(^ and ^)^, determine if the
input string is valid.
The brackets must close in the correct order, ]UV] and ]UV()] are all valid but ]U)] and ]U(V)] are
not.
ff G22i*Q/2- o HB/ S `2Mi?2b2b
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bbo HB/ Ubi`BM; +QMbi bV &
bi`BM; H27i 4 ]U(&]c
bi`BM; `B;?i 4 ]V)']c
bi +FI+? `= biFc
7Q` U miQ + , bV &
B7 UH27iX7BM/U+V 54 bi`BM;,,MTQbV &
biFXTmb? U+Vc
' 2Hb2 &
B7 UbiFX2KTiv UV %% biFXiQT UV 54 H27i(`B;?iX7BM/ U+V)V
`2im`M 7 Hb2c
2Hb2
biFXTQT UVc
'
'
79
80
'c
'
`2im`M biFX2KTivUVc
Generate Parentheses,
10.9
Longest Valid Parentheses,
4.1.2
4.1.2 Longest Valid Parentheses
Given a string containing just the characters ^U^ and ^V^, find the length of the longest valid (wellformed) parentheses substring.
For ]UUV], the longest valid parentheses substring is ]UV], which has length = 2.
Another example is ]VUVUVV], where the longest valid parentheses substring is ]UVUV], which has
length = 4.
ff G22i*Q/2- GQM;2bi o HB/ S `2Mi?2b2
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi HQM;2bio HB/S `2Mi?2b2bU+QMbi bi`BM; bV &
BMi K tnH2M 4 y- H bi 4 @Rc ff i?2 TQbBiBQM Q7 i?2 H bi ^V^
bi +FIBMi= H27ibc ff F22T i` +F Q7 i?2 TQbBiBQMb Q7 MQM@K i+?BM; ^U^b
7Q` UBMi B 4 yc B I bXbBx2UVc YYBV &
B7 Ub(B) 44^U^V &
H27ibXTmb?UBVc
' 2Hb2 &
B7 UH27ibX2KTivUVV &
ff MQ K i+?BM; H27i
H bi 4 Bc
' 2Hb2 &
ff 7BM/ K i+?BM; T B`
H27ibXTQTUVc
B7 UH27ibX2KTivUVV &
K tnH2M 4 K tUK tnH2M- B@H biVc
' 2Hb2 &
K tnH2M 4 K tUK tnH2M- B@H27ibXiQTUVVc
81
4.1
'
'c
'
'
'
'
`2im`M K tnH2Mc
Dynamic Programming, One Pass
ff G22i*Q/2- GQM;2bi o HB/ S `2Mi?2b2
ff
PUMV
PUMV
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfrDbQMV
+H bb aQHmiBQM &
Tm#HB+,
BMi HQM;2bio HB/S `2Mi?2b2bU+QMbi bi`BM; bV &
p2+iQ`IBMi= 7UbXbBx2UV- yVc
BMi `2i 4 yc
7Q` UBMi B 4 bXbBx2UV @ kc B =4 yc @@BV &
BMi K i+? 4 B Y 7(B Y R) Y Rc
ff + b2, ]UUXXXVV]
B7 Ub(B) 44 ^U^ K i+? I bXbBx2UV b(K i+?) 44 ^V^V &
7(B) 4 7(B Y R) Y kc
ff B7 p HB/ b2[m2M+2 2tBbi 7i2`r `/b ]UUXXXVVUV]
B7 UK i+? Y R I bXbBx2UVV 7(B) Y4 7(K i+? Y R)c
'
`2i 4 K tU`2i- 7(B)Vc
'
`2im`M `2ic
'
'c
ff G22i*Q/2- GQM;2bi o HB/ S `2Mi?2b2
ff
PUMV
PURV
ff ! mi?Q`
U?iiT,ffr2B#QX+QKf+T+bV
+H bb aQHmiBQM &
Tm#HB+,
BMi HQM;2bio HB/S `2Mi?2b2bU+QMbi bi`BM; bV &
BMi Mbr2` 4 y- /2Ti? 4 y- bi `i 4 @Rc
7Q` UBMi B 4 yc B I bXbBx2UVc YYBV &
B7 Ub(B) 44 ^U^V &
YY/2Ti?c
' 2Hb2 &
@@/2Ti?c
B7 U/2Ti? I yV &
bi `i 4 Bc
/2Ti? 4 yc
' 2Hb2 B7 U/2Ti? 44 yV &
Mbr2` 4 K tU Mbr2`- B @ bi `iVc
'
82
'
'c
'
'
/2Ti? 4 yc
bi `i 4 bXbBx2UVc
7Q` UBMi B 4 bXbBx2UV @ Rc B =4 yc @@BV &
B7 Ub(B) 44 ^V^V &
YY/2Ti?c
' 2Hb2 &
@@/2Ti?c
B7 U/2Ti? I yV &
bi `i 4 Bc
/2Ti? 4 yc
' 2Hb2 B7 U/2Ti? 44 yV &
Mbr2` 4 K tU Mbr2`- bi `i @ BVc
'
'
'
`2im`M Mbr2`c
Valid Parentheses,
Generate Parentheses,
4.1.1
10.9
4.1.3 Largest Rectangle in Histogram
Given n non-negative integers representing the histograms bar height where the width of each bar is 1,
find the area of largest rectangle in the histogram.
4-1
Above is a histogram where width of each bar is 1, given height = (k-R-8-e-k-j).
83
4.1
4-2
The largest rectangle is shown in the shaded area, which has area = 10 unit.
For example, Given height = (k-R-8-e-k-j), return 10.
Container With Most Water(12.6)
O(n2 )
4-2
i=4
3
3
3
4
ff G22i*Q/2- G `;2bi _2+i M;H2 BM >BbiQ;` K
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi H `;2bi_2+i M;H2`2 Up2+iQ`IBMi= ?2B;?iV &
bi +FIBMi= bc
?2B;?iXTmb?n# +FUyVc
BMi `2bmHi 4 yc
7Q` UBMi B 4 yc B I ?2B;?iXbBx2UVc V &
B7 UbX2KTivUV %% ?2B;?i(B) = ?2B;?i(bXiQTUV)V
bXTmb?UBYYVc
2Hb2 &
BMi iKT 4 bXiQTUVc
bXTQTUVc
`2bmHi 4 K tU`2bmHi?2B;?i(iKT)
UbX2KTivUV \ B , B @ bXiQTUV @ RVVc
'
'
`2im`M `2bmHic
84
'c
'
Trapping Rain Water, 2.1.15
Container With Most Water, 12.6
4.1.4 Evaluate Reverse Polish Notation
Evaluate the value of an arithmetic expression in Reverse Polish Notation.
Valid operators are Y- @-
- f. Each operand may be an integer or another expression.
Some examples:
(]k]- ]R]- ]Y]- ]j]- ] ]) @= UUk Y RV
jV @= N
(]9]- ]Rj]- ]8]- ]f]- ]Y]) @= U9 Y URj f 8VV @= e
ff G22i*Q/2- 1p Hm i2 _2p2`b2 SQHBb? LQi iBQM
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi 2p H_SLUp2+iQ`Ibi`BM;= iQF2MbV &
BMi t- vc
miQ iQF2M 4 iQF2MbX# +FUVc iQF2MbXTQTn# +FUVc
B7 UBbnQT2` iQ`UiQF2MVV &
v 4 2p H_SLUiQF2MbVc
t 4 2p H_SLUiQF2MbVc
B7 UiQF2M(y) 44 ^Y^V
t Y4 vc
2Hb2 B7 UiQF2M(y) 44 ^@^V t @4 vc
2Hb2 B7 UiQF2M(y) 44 ^ ^V t 4 vc
2Hb2
t f4 vc
' 2Hb2 &
bBx2ni Bc
t 4 biQBUiQF2M- BVc
'
`2im`M tc
'
T`Bp i2,
#QQH BbnQT2` iQ`U+QMbi bi`BM; QTV &
`2im`M QTXbBx2UV 44 R bi`BM;U]Y@ f]VX7BM/UQTV 54 bi`BM;,,MTQbc
'
'c
85
4.2
ff G22i*Q/2- J t SQBMib QM GBM2
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi 2p H_SLUp2+iQ`Ibi`BM;= iQF2MbV &
bi +FIbi`BM;= bc
7Q` U miQ iQF2M , iQF2MbV &
B7 U5BbnQT2` iQ`UiQF2MVV &
bXTmb?UiQF2MVc
' 2Hb2 &
BMi v 4 biQBUbXiQTUVVc
bXTQTUVc
BMi t 4 biQBUbXiQTUVVc
bXTQTUVc
B7 UiQF2M(y) 44 ^Y^V
t Y4 vc
2Hb2 B7 UiQF2M(y) 44 ^@^V t @4 vc
2Hb2 B7 UiQF2M(y) 44 ^ ^V t 4 vc
2Hb2
t f4 vc
bXTmb?UiQnbi`BM;UtVVc
'
'
`2im`M biQBUbXiQTUVVc
'
T`Bp i2,
#QQH BbnQT2` iQ`U+QMbi bi`BM; QTV &
`2im`M QTXbBx2UV 44 R bi`BM;U]Y@ f]VX7BM/UQTV 54 bi`BM;,,MTQbc
'
'c
4.2
LeetCode
ff
bi`m+i h`22LQ/2 &
BMi p Hc
h`22LQ/2 H27ic
h`22LQ/2 `B;?ic
h`22LQ/2UBMi tV , p HUtV- H27iUMmHHTi`V- `B;?iUMmHHTi`V & '
'c
5.1
(root->left->right) root->right->left
>right->root) right->left->root
(left->root->right)
5.1.1 Binary Tree Preorder Traversal
Given a binary tree, return the preorder traversal of its nodes values.
For example: Given binary tree &R-O-k-j',
R
(left-
$
k
f
return (R-k-j).
Note: Recursive solution is trivial, could you do it iteratively?
86
87
5.1
Morris
ff G22i*Q/2- "BM `v h`22 S`2Q`/2` h` p2`b H
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= T`2Q`/2`h` p2`b HUh`22LQ/2 `QQiV &
p2+iQ`IBMi= `2bmHic
bi +FI+QMbi h`22LQ/2 = bc
B7 U`QQi 54 MmHHTi`V bXTmb?U`QQiVc
r?BH2 U5bX2KTivUVV &
+QMbi h`22LQ/2 T 4 bXiQTUVc
bXTQTUVc
`2bmHiXTmb?n# +FUT@=p HVc
B7 UT@=`B;?i 54 MmHHTi`V bXTmb?UT@=`B;?iVc
B7 UT@=H27i 54 MmHHTi`V bXTmb?UT@=H27iVc
'c
'
'
`2im`M `2bmHic
Morris
ff G22i*Q/2- "BM `v h`22 S`2Q`/2` h` p2`b H
ff JQ``Bb
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= T`2Q`/2`h` p2`b HUh`22LQ/2 `QQiV &
p2+iQ`IBMi= `2bmHic
h`22LQ/2 +m` 4 `QQi- T`2p 4 MmHHTi`c
r?BH2 U+m` 54 MmHHTi`V &
B7 U+m`@=H27i 44 MmHHTi`V &
`2bmHiXTmb?n# +FU+m`@=p HVc
T`2p 4 +m`c f +m`
f
+m` 4 +m`@=`B;?ic
' 2Hb2 &
f
f
h`22LQ/2 MQ/2 4 +m`@=H27ic
r?BH2 UMQ/2@=`B;?i 54 MmHHTi` MQ/2@=`B;?i 54 +m`V
MQ/2 4 MQ/2@=`B;?ic
B7 UMQ/2@=`B;?i 44 MmHHTi`V & f
`2bmHiXTmb?n# +FU+m`@=p HVc f
MQ/2@=`B;?i 4 +m`c
T`2p 4 +m`c f +m`
f
f
88
5
+m` 4 +m`@=H27ic
' 2Hb2 &
f
MQ/2@=`B;?i 4 MmHHTi`c
f T`2p 4 +m`c
+m` 4 +m`@=`B;?ic
'
'
'c
f
+m`
'
'
`2im`M `2bmHic
Binary Tree Inorder Traversal
Binary Tree Postorder Traversal
Recover Binary Search Tree
5.1.2
5.1.3
5.1.7
5.1.2 Binary Tree Inorder Traversal
Given a binary tree, return the inorder traversal of its nodes values.
For example: Given binary tree &R-O-k-j',
R
$
k
f
return (R-j-k).
Note: Recursive solution is trivial, could you do it iteratively?
Morris
ff G22i*Q/2- "BM `v h`22 AMQ`/2` h` p2`b H
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= BMQ`/2`h` p2`b HUh`22LQ/2 `QQiV &
p2+iQ`IBMi= `2bmHic
bi +FI+QMbi h`22LQ/2 = bc
+QMbi h`22LQ/2 T 4 `QQic
89
5.1
'c
'
r?BH2 U5bX2KTivUV %% T 54 MmHHTi`V &
B7 UT 54 MmHHTi`V &
bXTmb?UTVc
T 4 T@=H27ic
' 2Hb2 &
T 4 bXiQTUVc
bXTQTUVc
`2bmHiXTmb?n# +FUT@=p HVc
T 4 T@=`B;?ic
'
'
`2im`M `2bmHic
Morris
ff G22i*Q/2- "BM `v h`22 AMQ`/2` h` p2`b H
ff JQ``Bb
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= BMQ`/2`h` p2`b HUh`22LQ/2 `QQiV &
p2+iQ`IBMi= `2bmHic
h`22LQ/2 +m` 4 `QQi- T`2p 4 MmHHTi`c
r?BH2 U+m` 54 MmHHTi`V &
B7 U+m`@=H27i 44 MmHHTi`V &
`2bmHiXTmb?n# +FU+m`@=p HVc
T`2p 4 +m`c
+m` 4 +m`@=`B;?ic
' 2Hb2 &
f
f
h`22LQ/2 MQ/2 4 +m`@=H27ic
r?BH2 UMQ/2@=`B;?i 54 MmHHTi` MQ/2@=`B;?i 54 +m`V
MQ/2 4 MQ/2@=`B;?ic
B7 UMQ/2@=`B;?i 44 MmHHTi`V & f
MQ/2@=`B;?i 4 +m`c
f T`2p 4 +m`c
+m`
+m` 4 +m`@=H27ic
' 2Hb2 &
f
`2bmHiXTmb?n# +FU+m`@=p HVc
MQ/2@=`B;?i 4 MmHHTi`c
T`2p 4 +m`c
+m` 4 +m`@=`B;?ic
'
'c
'
'
'
`2im`M `2bmHic
f
f
f
90
Binary Tree Preorder Traversal
Binary Tree Postorder Traversal
Recover Binary Search Tree
5.1.1
5.1.3
5.1.7
5.1.3 Binary Tree Postorder Traversal
Given a binary tree, return the postorder traversal of its nodes values.
For example: Given binary tree &R-O-k-j',
R
$
k
f
return (j-k-R).
Note: Recursive solution is trivial, could you do it iteratively?
Morris
ff G22i*Q/2- "BM `v h`22 SQbiQ`/2` h` p2`b H
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= TQbiQ`/2`h` p2`b HUh`22LQ/2 `QQiV &
p2+iQ`IBMi= `2bmHic
bi +FI+QMbi h`22LQ/2 = bc
f T
[
f
+QMbi h`22LQ/2 T 4 `QQi- [ 4 MmHHTi`c
/Q &
r?BH2 UT 54 MmHHTi`V & f
bXTmb?UTVc
T 4 T@=H27ic
'
[ 4 MmHHTi`c
r?BH2 U5bX2KTivUVV &
T 4 bXiQTUVc
bXTQTUVc
f
B7 UT@=`B;?i 44 [V &
91
5.1
`2bmHiXTmb?n# +FUT@=p HVc
[ 4 Tc f
' 2Hb2 &
f
bXTmb?UTVc
f
f
T 4 T@=`B;?ic
#`2 Fc
'
f
f
'
' r?BH2 U5bX2KTivUVVc
'c
'
`2im`M `2bmHic
Morris
ff G22i*Q/2- "BM `v h`22 SQbiQ`/2` h` p2`b H
ff JQ``Bb
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= TQbiQ`/2`h` p2`b HUh`22LQ/2 `QQiV &
p2+iQ`IBMi= `2bmHic
h`22LQ/2 /mKKvU@RVc
h`22LQ/2 +m`- T`2p 4 MmHHTi`c
bi/,,7mM+iBQM I pQB/U+QMbi h`22LQ/2 V= pBbBi 4
( `2bmHi)U+QMbi h`22LQ/2 MQ/2V&
`2bmHiXTmb?n# +FUMQ/2@=p HVc
'c
/mKKvXH27i 4 `QQic
+m` 4 /mKKvc
r?BH2 U+m` 54 MmHHTi`V &
B7 U+m`@=H27i 44 MmHHTi`V &
T`2p 4 +m`c f
f
+m` 4 +m`@=`B;?ic
' 2Hb2 &
h`22LQ/2 MQ/2 4 +m`@=H27ic
r?BH2 UMQ/2@=`B;?i 54 MmHHTi` MQ/2@=`B;?i 54 +m`V
MQ/2 4 MQ/2@=`B;?ic
'
B7 UMQ/2@=`B;?i 44 MmHHTi`V & f
MQ/2@=`B;?i 4 +m`c
T`2p 4 +m`c f
f
+m` 4 +m`@=H27ic
' 2Hb2 & f
pBbBin`2p2`b2U+m`@=H27i- T`2p- pBbBiVc
T`2p@=`B;?i 4 MmHHTi`c
T`2p 4 +m`c f
f
+m` 4 +m`@=`B;?ic
'
92
5
'
`2im`M `2bmHic
'
T`Bp i2,
ff
bi iB+ pQB/ `2p2`b2Uh`22LQ/2 7`QK- h`22LQ/2 iQV &
h`22LQ/2 t 4 7`QK- v 4 7`QK@=`B;?i- xc
B7 U7`QK 44 iQV `2im`Mc
'
r?BH2 Ut 54 iQV &
x 4 v@=`B;?ic
v@=`B;?i 4 tc
t 4 vc
v 4 xc
'
ff
bi iB+ pQB/ pBbBin`2p2`b2Uh`22LQ/2 7`QK- h`22LQ/2 iQbi/,,7mM+iBQMI pQB/U+QMbi h`22LQ/2 V = pBbBiV &
h`22LQ/2 T 4 iQc
`2p2`b2U7`QK- iQVc
r?BH2 Ui`m2V &
pBbBiUTVc
B7 UT 44 7`QKV
#`2 Fc
T 4 T@=`B;?ic
'
'
'c
`2p2`b2UiQ- 7`QKVc
Binary Tree Preorder Traversal
Binary Tree Inorder Traversal
Recover Binary Search Tree
5.1.1
5.1.2
5.1.7
5.1.4 Binary Tree Level Order Traversal
Given a binary tree, return the level order traversal of its nodes values. (ie, from left to right, level by
level).
For example: Given binary tree &j-N-ky-O-O-R8-d',
93
5.1
j
f $
N ky
f $
R8
d
return its level order traversal as:
(
(j)(N-ky)(R8-d)
ff G22i*Q/2- "BM `v h`22 G2p2H P`/2` h` p2`b H
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = H2p2HP`/2`Uh`22LQ/2 `QQiV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
i` p2`b2U`QQi- R- `2bmHiVc
`2im`M `2bmHic
'
pQB/ i` p2`b2Uh`22LQ/2
B7 U5`QQiV `2im`Mc
`QQi- bBx2ni H2p2H- p2+iQ`Ip2+iQ`IBMi== `2bmHiV &
B7 UH2p2H = `2bmHiXbBx2UVV
`2bmHiXTmb?n# +FUp2+iQ`IBMi=UVVc
'c
'
`2bmHi(H2p2H@R)XTmb?n# +FU`QQi@=p HVc
i` p2`b2U`QQi@=H27i- H2p2HYR- `2bmHiVc
i` p2`b2U`QQi@=`B;?i- H2p2HYR- `2bmHiVc
ff G22i*Q/2- "BM `v h`22 G2p2H P`/2` h` p2`b H
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = H2p2HP`/2`Uh`22LQ/2 `QQiV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
[m2m2Ih`22LQ/2 = +m``2Mi- M2tic
94
5
B7U`QQi 44 MmHHTi`V &
`2im`M `2bmHic
' 2Hb2 &
+m``2MiXTmb?U`QQiVc
'
'c
'
r?BH2 U5+m``2MiX2KTivUVV &
p2+iQ`IBMi= H2p2Hc ff 2HK2Mib BM QM2 H2p2H
r?BH2 U5+m``2MiX2KTivUVV &
h`22LQ/2 MQ/2 4 +m``2MiX7`QMiUVc
+m``2MiXTQTUVc
H2p2HXTmb?n# +FUMQ/2@=p HVc
B7 UMQ/2@=H27i 54 MmHHTi`V M2tiXTmb?UMQ/2@=H27iVc
B7 UMQ/2@=`B;?i 54 MmHHTi`V M2tiXTmb?UMQ/2@=`B;?iVc
'
`2bmHiXTmb?n# +FUH2p2HVc
br TUM2ti- +m``2MiVc
'
`2im`M `2bmHic
Binary Tree Level Order Traversal II
Binary Tree Zigzag Level Order Traversal
5.1.5
5.1.6
5.1.5 Binary Tree Level Order Traversal II
Given a binary tree, return the bottom-up level order traversal of its nodes values. (ie, from left to right,
level by level from leaf to root).
For example: Given binary tree &j-N-ky-O-O-R8-d',
j
f $
N ky
f $
R8
d
return its bottom-up level order traversal as:
(
(R8-d)
(N-ky)(j)-
95
5.1
5.1.4
`2p2`b2UV
ff G22i*Q/2- "BM `v h`22 G2p2H P`/2` h` p2`b H AA
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = H2p2HP`/2`"QiiQKUh`22LQ/2 `QQiV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
i` p2`b2U`QQi- R- `2bmHiVc
bi/,,`2p2`b2U`2bmHiX#2;BMUV- `2bmHiX2M/UVVc ff
`2im`M `2bmHic
'
pQB/ i` p2`b2Uh`22LQ/2
B7 U5`QQiV `2im`Mc
`QQi- bBx2ni H2p2H- p2+iQ`Ip2+iQ`IBMi== `2bmHiV &
B7 UH2p2H = `2bmHiXbBx2UVV
`2bmHiXTmb?n# +FUp2+iQ`IBMi=UVVc
'c
'
`2bmHi(H2p2H@R)XTmb?n# +FU`QQi@=p HVc
i` p2`b2U`QQi@=H27i- H2p2HYR- `2bmHiVc
i` p2`b2U`QQi@=`B;?i- H2p2HYR- `2bmHiVc
ff G22i*Q/2- "BM `v h`22 G2p2H P`/2` h` p2`b H AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = H2p2HP`/2`"QiiQKUh`22LQ/2
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
B7U`QQi 44 MmHHTi`V `2im`M `2bmHic
`QQiV &
[m2m2Ih`22LQ/2 = +m``2Mi- M2tic
p2+iQ`IBMi= H2p2Hc ff 2HK2Mib BM H2p2H H2p2H
+m``2MiXTmb?U`QQiVc
r?BH2 U5+m``2MiX2KTivUVV &
r?BH2 U5+m``2MiX2KTivUVV &
h`22LQ/2 MQ/2 4 +m``2MiX7`QMiUVc
+m``2MiXTQTUVc
H2p2HXTmb?n# +FUMQ/2@=p HVc
B7 UMQ/2@=H27i 54 MmHHTi`V M2tiXTmb?UMQ/2@=H27iVc
B7 UMQ/2@=`B;?i 54 MmHHTi`V M2tiXTmb?UMQ/2@=`B;?iVc
'
`2bmHiXTmb?n# +FUH2p2HVc
96
5
H2p2HX+H2 `UVc
br TUM2ti- +m``2MiVc
'c
'
'
`2p2`b2U`2bmHiX#2;BMUV- `2bmHiX2M/UVVc ff
`2im`M `2bmHic
Binary Tree Level Order Traversal
5.1.4
Binary Tree Zigzag Level Order Traversal
5.1.6
5.1.6 Binary Tree Zigzag Level Order Traversal
Given a binary tree, return the zigzag level order traversal of its nodes values. (ie, from left to right,
then right to left for the next level and alternate between).
For example: Given binary tree j-N-ky-O-O-R8-d,
j
f $
N ky
f $
R8
d
return its zigzag level order traversal as:
(
(j)(ky-N)(R8-d)
bool
ff G22i*Q/2- "BM `v h`22 wB;x ; G2p2H P`/2` h` p2`b H
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = xB;x ;G2p2HP`/2`Uh`22LQ/2 `QQiV &
p2+iQ`Ip2+iQ`IBMi== `2bmHic
i` p2`b2U`QQi- R- `2bmHi- i`m2Vc
`2im`M `2bmHic
97
5.1
'
pQB/ i` p2`b2Uh`22LQ/2 `QQi- bBx2ni H2p2H- p2+iQ`Ip2+iQ`IBMi== `2bmHi#QQH H27iniQn`B;?iV &
B7 U5`QQiV `2im`Mc
B7 UH2p2H = `2bmHiXbBx2UVV
`2bmHiXTmb?n# +FUp2+iQ`IBMi=UVVc
B7 UH27iniQn`B;?iV
`2bmHi(H2p2H@R)XTmb?n# +FU`QQi@=p HVc
2Hb2
`2bmHi(H2p2H@R)XBMb2`iU`2bmHi(H2p2H@R)X#2;BMUV- `QQi@=p HVc
'c
'
i` p2`b2U`QQi@=H27i- H2p2HYR- `2bmHi- 5H27iniQn`B;?iVc
i` p2`b2U`QQi@=`B;?i- H2p2HYR- `2bmHi- 5H27iniQn`B;?iVc
ffG22i*Q/2- "BM `v h`22 wB;x ; G2p2H P`/2` h` p2`b H
ff
#QQH
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = xB;x ;G2p2HP`/2`Uh`22LQ/2 `QQiV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
[m2m2Ih`22LQ/2 = +m``2Mi- M2tic
#QQH H27iniQn`B;?i 4 i`m2c
B7U`QQi 44 MmHHTi`V &
`2im`M `2bmHic
' 2Hb2 &
+m``2MiXTmb?U`QQiVc
'
'
r?BH2 U5+m``2MiX2KTivUVV &
p2+iQ`IBMi= H2p2Hc ff 2HK2Mib BM QM2 H2p2H
r?BH2 U5+m``2MiX2KTivUVV &
h`22LQ/2 MQ/2 4 +m``2MiX7`QMiUVc
+m``2MiXTQTUVc
H2p2HXTmb?n# +FUMQ/2@=p HVc
B7 UMQ/2@=H27i 54 MmHHTi`V M2tiXTmb?UMQ/2@=H27iVc
B7 UMQ/2@=`B;?i 54 MmHHTi`V M2tiXTmb?UMQ/2@=`B;?iVc
'
B7 U5H27iniQn`B;?iV `2p2`b2UH2p2HX#2;BMUV- H2p2HX2M/UVVc
`2bmHiXTmb?n# +FUH2p2HVc
H27iniQn`B;?i 4 5H27iniQn`B;?ic
br TUM2ti- +m``2MiVc
'
`2im`M `2bmHic
98
'c
Binary Tree Level Order Traversal
Binary Tree Level Order Traversal II
5.1.4
5.1.5
5.1.7 Recover Binary Search Tree
Two elements of a binary search tree (BST) are swapped by mistake.
Recover the tree without changing its structure.
Note: A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?
O(n)
Morris
O(n)
ff G22i*Q/2- _2+Qp2` "BM `v a2 `+? h`22
ff JQ``Bb
PUMV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ `2+Qp2`h`22Uh`22LQ/2 `QQiV &
T B`Ih`22LQ/2 - h`22LQ/2 = #`QF2Mc
h`22LQ/2 T`2p 4 MmHHTi`c
h`22LQ/2 +m` 4 `QQic
PURV
r?BH2 U+m` 54 MmHHTi`V &
B7 U+m`@=H27i 44 MmHHTi`V &
/2i2+iU#`QF2M- T`2p- +m`Vc
T`2p 4 +m`c
+m` 4 +m`@=`B;?ic
' 2Hb2 &
miQ MQ/2 4 +m`@=H27ic
r?BH2 UMQ/2@=`B;?i 54 MmHHTi` MQ/2@=`B;?i 54 +m`V
MQ/2 4 MQ/2@=`B;?ic
B7 UMQ/2@=`B;?i 44 MmHHTi`V &
MQ/2@=`B;?i 4 +m`c
ffT`2p 4 +m`c
+m`
99
5.1
'
'
'c
'
+m` 4 +m`@=H27ic
' 2Hb2 &
/2i2+iU#`QF2M- T`2p- +m`Vc
MQ/2@=`B;?i 4 MmHHTi`c
T`2p 4 +m`c
+m` 4 +m`@=`B;?ic
'
br TU#`QF2MX7B`bi@=p H- #`QF2MXb2+QM/@=p HVc
pQB/ /2i2+iUT B`Ih`22LQ/2 - h`22LQ/2 = #`QF2M- h`22LQ/2 T`2ph`22LQ/2 +m``2MiV &
B7 UT`2p 54 MmHHTi` T`2p@=p H = +m``2Mi@=p HV &
B7 U#`QF2MX7B`bi 44 MmHHTi`V &
#`QF2MX7B`bi 4 T`2pc
' ff
2Hb2
&y-R'
br T
b2+QM/
MmHHTi`
ff
_mMiBK2 1``Q`
#`QF2MXb2+QM/ 4 +m``2Mic
'
'
Binary Tree Inorder Traversal
5.1.2
5.1.8 Same Tree
Given two binary trees, write a function to check if they are equal or not.
Two binary trees are considered equal if they are structurally identical and the nodes have the same value.
ff G22i*Q/2- a K2 h`22
ff
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bba K2h`22Uh`22LQ/2
PUHQ;MV
T- h`22LQ/2
[V &
100
'c
'
B7 U5T 5[V `2im`M i`m2c
ff
B7 U5T %% 5[V `2im`M 7 Hb2c ff
`2im`M T@=p H 44 [@=p H
ff
Bba K2h`22UT@=H27i- [@=H27iV
Bba K2h`22UT@=`B;?i- [@=`B;?iVc
ff G22i*Q/2- a K2 h`22
ff
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bba K2h`22Uh`22LQ/2
bi +FIh`22LQ/2 = bc
bXTmb?UTVc
bXTmb?U[Vc
PUHQ;MV
T- h`22LQ/2
[V &
r?BH2U5bX2KTivUVV &
T 4 bXiQTUVc bXTQTUVc
[ 4 bXiQTUVc bXTQTUVc
B7 U5T 5[V +QMiBMm2c
B7 U5T %% 5[V `2im`M 7 Hb2c
B7 UT@=p H 54 [@=p HV `2im`M 7 Hb2c
bXTmb?UT@=H27iVc
bXTmb?U[@=H27iVc
bXTmb?UT@=`B;?iVc
bXTmb?U[@=`B;?iVc
'c
'
'
`2im`M i`m2c
Symmetric Tree
5.1.9
5.1.9 Symmetric Tree
Given two binary trees, write a function to check if they are equal or not.
Two binary trees are considered equal if they are structurally identical and the nodes have the same value.
101
5.1
ff G22i*Q/2- avKK2i`B+ h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbavKK2i`B+Uh`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`M i`m2c
`2im`M BbavKK2i`B+U`QQi@=H27i- `QQi@=`B;?iVc
'
#QQH BbavKK2i`B+Uh`22LQ/2 T- h`22LQ/2 [V &
B7 UT 44 MmHHTi` [ 44 MmHHTi`V `2im`M i`m2c
B7 UT 44 MmHHTi` %% [ 44 MmHHTi`V `2im`M 7 Hb2c
`2im`M T@=p H 44 [@=p H
ff
BbavKK2i`B+UT@=H27i- [@=`B;?iV
BbavKK2i`B+UT@=`B;?i- [@=H27iVc
'
'c
ff G22i*Q/2- avKK2i`B+ h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbavKK2i`B+ Uh`22LQ/2 `QQiV &
B7 U5`QQiV `2im`M i`m2c
bi +FIh`22LQ/2 = bc
bXTmb?U`QQi@=H27iVc
bXTmb?U`QQi@=`B;?iVc
r?BH2 U5bX2KTiv UVV &
miQ T 4 bXiQT UVc bXTQTUVc
miQ [ 4 bXiQT UVc bXTQTUVc
B7 U5T 5[V +QMiBMm2c
B7 U5T %% 5[V `2im`M 7 Hb2c
B7 UT@=p H 54 [@=p HV `2im`M 7 Hb2c
bXTmb?UT@=H27iVc
bXTmb?U[@=`B;?iVc
'
bXTmb?UT@=`B;?iVc
bXTmb?U[@=H27iVc
`2im`M i`m2c
ff
ff
102
5
'
'c
Same Tree
5.1.8
5.1.10 Balanced Binary Tree
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two
subtrees of every node never differ by more than 1.
ff G22i*Q/2- " H M+2/ "BM `v h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bb" H M+2/ Uh`22LQ/2 `QQiV &
`2im`M # H M+2/>2B;?i U`QQiV =4 yc
'
f
_2im`Mb i?2 ?2B;?i Q7 <`QQi< B7 <`QQi< Bb # H M+2/ i`22Qi?2`rBb2- `2im`Mb <@R<X
f
BMi # H M+2/>2B;?i Uh`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`M yc ff
BMi H27i 4 # H M+2/>2B;?i U`QQi@=H27iVc
BMi `B;?i 4 # H M+2/>2B;?i U`QQi@=`B;?iVc
B7 UH27i I y %% `B;?i I y %% #bUH27i @ `B;?iV = RV `2im`M @Rc
'c
'
`2im`M K tUH27i- `B;?iV Y Rc ff
ff
103
5.1
5.1.11 Flatten Binary Tree to Linked List
Given a binary tree, flatten it to a linked list in-place.
For example, Given
R
f $
k
8
f $
$
j
9
e
The flattened tree should look like:
R
$
k
$
j
$
9
$
8
$
e
1
ff G22i*Q/2- 6H ii2M "BM `v h`22 iQ GBMF2/ GBbi
ff
R
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ 7H ii2MUh`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`Mc ff
7H ii2MU`QQi@=H27iVc
7H ii2MU`QQi@=`B;?iVc
B7 UMmHHTi` 44 `QQi@=H27iV `2im`Mc
'c
'
ff
h`22LQ/2 T 4 `QQi@=H27ic
r?BH2UT@=`B;?iV T 4 T@=`B;?ic ff
T@=`B;?i 4 `QQi@=`B;?ic
`QQi@=`B;?i 4 `QQi@=H27ic
`QQi@=H27i 4 MmHHTi`c
`QQi
`QQi@=`B;?i
104
2
ff G22i*Q/2- 6H ii2M "BM `v h`22 iQ GBMF2/ GBbi
ff
k
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfmfRkj9N39R98V
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ 7H ii2MUh`22LQ/2 `QQiV &
7H ii2MU`QQi- LlGGVc
'
T`Bp i2,
ff
`QQi
i BH
h`22LQ/2 7H ii2MUh`22LQ/2 `QQi- h`22LQ/2 i BHV &
B7 ULlGG 44 `QQiV `2im`M i BHc
'c
'
`QQi@=`B;?i 4 7H ii2MU`QQi@=H27i- 7H ii2MU`QQi@=`B;?i- i BHVVc
`QQi@=H27i 4 LlGGc
`2im`M `QQic
ff G22i*Q/2- 6H ii2M "BM `v h`22 iQ GBMF2/ GBbi
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ 7H ii2MUh`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`Mc
bi +FIh`22LQ/2 = bc
bXTmb?U`QQiVc
r?BH2 U5bX2KTivUVV &
miQ T 4 bXiQTUVc
bXTQTUVc
B7 UT@=`B;?iV
bXTmb?UT@=`B;?iVc
B7 UT@=H27iV
bXTmb?UT@=H27iVc
'c
'
'
T@=H27i 4 MmHHTi`c
B7 U5bX2KTivUVV
T@=`B;?i 4 bXiQTUVc
105
5.1
5.1.12 Populating Next Right Pointers in Each Node II
Follow up for problem Populating Next Right Pointers in Each Node.
What if the given tree could be any binary tree? Would your previous solution still work?
Note: You may only use constant extra space.
For example, Given the following binary tree,
R
f $
k
j
f $
$
9
8
d
After calling your function, the tree should look like:
R @= LlGG
f $
k @= j @= LlGG
f $
$
9@= 8 @= d @= LlGG
Populating Next Right Pointers in Each Node I.
ff G22i*Q/2- SQTmH iBM; L2ti _B;?i SQBMi2`b BM 1 +? LQ/2 AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ +QMM2+iUh`22GBMFLQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`Mc
h`22GBMFLQ/2 /mKKvU@RVc
7Q` Uh`22GBMFLQ/2 +m`` 4 `QQi- T`2p 4 /mKKvc
+m``c +m`` 4 +m``@=M2tiV &
B7 U+m``@=H27i 54 MmHHTi`V&
T`2p@=M2ti 4 +m``@=H27ic
T`2p 4 T`2p@=M2tic
'
B7 U+m``@=`B;?i 54 MmHHTi`V&
106
5
T`2p@=M2ti 4 +m``@=`B;?ic
T`2p 4 T`2p@=M2tic
'
'c
'
'
+QMM2+iU/mKKvXM2tiVc
ff G22i*Q/2- SQTmH iBM; L2ti _B;?i SQBMi2`b BM 1 +? LQ/2 AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ +QMM2+iUh`22GBMFLQ/2 `QQiV &
r?BH2 U`QQiV &
h`22GBMFLQ/2
M2ti 4 MmHHTi`c ff i?2 7B`bi MQ/2 Q7 M2ti H2p2H
h`22GBMFLQ/2
T`2p 4 MmHHTi`c ff T`2pBQmb MQ/2 QM i?2 b K2 H2p2H
7Q` Uc `QQic `QQi 4 `QQi@=M2tiV &
B7 U5M2tiV M2ti 4 `QQi@=H27i \ `QQi@=H27i , `QQi@=`B;?ic
B7 U`QQi@=H27iV &
B7 UT`2pV T`2p@=M2ti 4 `QQi@=H27ic
T`2p 4 `QQi@=H27ic
'
B7 U`QQi@=`B;?iV &
B7 UT`2pV T`2p@=M2ti 4 `QQi@=`B;?ic
T`2p 4 `QQi@=`B;?ic
'
'
'c
'
'
`QQi 4 M2tic ff im`M iQ M2ti H2p2H
Populating Next Right Pointers in Each Node
5.4.6
5.2
5.2.1 Construct Binary Tree from Preorder and Inorder Traversal
Given preorder and inorder traversal of a tree, construct the binary tree.
Note: You may assume that duplicates do not exist in the tree.
107
5.2
ff G22i*Q/2- *QMbi`m+i "BM `v h`22 7`QK S`2Q`/2` M/ AMQ`/2` h` p2`b H
ff
PUMV
PU$HQ;MV
+H bb aQHmiBQM &
Tm#HB+,
h`22LQ/2 #mBH/h`22Up2+iQ`IBMi= T`2Q`/2`- p2+iQ`IBMi= BMQ`/2`V &
`2im`M #mBH/h`22U#2;BMUT`2Q`/2`V- 2M/UT`2Q`/2`V#2;BMUBMQ`/2`V- 2M/UBMQ`/2`VVc
'
i2KTH i2IivT2M K2 AMTmiAi2` iQ`=
h`22LQ/2 #mBH/h`22UAMTmiAi2` iQ` T`2n7B`bi- AMTmiAi2` iQ` T`2nH biAMTmiAi2` iQ` BMn7B`bi- AMTmiAi2` iQ` BMnH biV &
B7 UT`2n7B`bi 44 T`2nH biV `2im`M MmHHTi`c
B7 UBMn7B`bi 44 BMnH biV `2im`M MmHHTi`c
miQ `QQi 4 M2r h`22LQ/2U T`2n7B`biVc
miQ BM_QQiSQb 4 7BM/UBMn7B`bi- BMnH bi- T`2n7B`biVc
miQ H27iaBx2 4 /Bbi M+2UBMn7B`bi- BM_QQiSQbVc
`QQi@=H27i 4 #mBH/h`22UM2tiUT`2n7B`biV- M2tiUT`2n7B`biH27iaBx2 Y RV- BMn7B`bi- M2tiUBMn7B`bi- H27iaBx2VVc
`QQi@=`B;?i 4 #mBH/h`22UM2tiUT`2n7B`bi- H27iaBx2 Y RV- T`2nH biM2tiUBM_QQiSQbV- BMnH biVc
'c
'
`2im`M `QQic
Construct Binary Tree from Inorder and Postorder Traversal
5.2.2
5.2.2 Construct Binary Tree from Inorder and Postorder Traversal
Given inorder and postorder traversal of a tree, construct the binary tree.
Note: You may assume that duplicates do not exist in the tree.
108
ff G22i*Q/2- *QMbi`m+i "BM `v h`22 7`QK AMQ`/2` M/ SQbiQ`/2` h` p2`b H
ff
PUMV
PU$HQ;MV
+H bb aQHmiBQM &
Tm#HB+,
h`22LQ/2 #mBH/h`22Up2+iQ`IBMi= BMQ`/2`- p2+iQ`IBMi= TQbiQ`/2`V &
`2im`M #mBH/h`22U#2;BMUBMQ`/2`V- 2M/UBMQ`/2`V#2;BMUTQbiQ`/2`V- 2M/UTQbiQ`/2`VVc
'
i2KTH i2IivT2M K2 "B/BAi=
h`22LQ/2 #mBH/h`22U"B/BAi BMn7B`bi- "B/BAi BMnH bi"B/BAi TQbin7B`bi- "B/BAi TQbinH biV &
B7 UBMn7B`bi 44BMnH biV `2im`M MmHHTi`c
B7 UTQbin7B`bi 44 TQbinH biV `2im`M MmHHTi`c
+QMbi miQ p H 4 T`2pUTQbinH biVc
h`22LQ/2 `QQi 4 M2r h`22LQ/2Up HVc
miQ BMn`QQinTQb 4 7BM/UBMn7B`bi- BMnH bi- p HVc
miQ H27inbBx2 4 /Bbi M+2UBMn7B`bi- BMn`QQinTQbVc
miQ TQbinH27inH bi 4 M2tiUTQbin7B`bi- H27inbBx2Vc
`QQi@=H27i 4 #mBH/h`22UBMn7B`bi- BMn`QQinTQb- TQbin7B`bi- TQbinH27inH biVc
`QQi@=`B;?i 4 #mBH/h`22UM2tiUBMn`QQinTQbV- BMnH bi- TQbinH27inH biT`2pUTQbinH biVVc
`2im`M `QQic
'
'c
Construct Binary Tree from Preorder and Inorder Traversal
5.2.1
5.3
5.3.1 Unique Binary Search Trees
Given n, how many structurally unique BSTs (binary search trees) that store values 1...n?
For example, Given n = 3, there are a total of 5 unique BSTs.
R
$
f
j
R
k
f
j
f
R
$
k
k
f $
R
j
$
j
109
5.3
R
$
$
j
f
k
f $
f
R
j
R
j
f
$
k
1
BST
1, 2, 3, ..., n
[1, i-1]
[i+1, n]
f (i)
Unique Binary Search Tree
[1, i]
BST
1
f (0) = 1
BST
f (1) = 1
1,2
R
k
f
f (2)
f (0) f (1)
f (1) f (0)
BST
f (3)
f (0) f (2)
f (1) f (1)
f (2) f (0)
f
f (i) =
i
)
k=1
f (k 1) f (i k)
ff G22i*Q/2- lMB[m2 "BM `v a2 `+? h`22b
ff
PUM kV
PUMV
+H bb aQHmiBQM &
110
Tm#HB+,
BMi MmKh`22bUBMi MV &
p2+iQ`IBMi= 7UM Y R- yVc
7(y) 4 Rc
7(R) 4 Rc
7Q` UBMi B 4 kc B I4 Mc YYBV &
7Q` UBMi F 4 Rc F I4 Bc YYFV
7(B) Y4 7(F@R)
7(B @ F)c
'
'c
'
`2im`M 7(M)c
Unique Binary Search Trees II
5.3.2
5.3.2 Unique Binary Search Trees II
Given n, generate all structurally unique BSTs (binary search trees) that store values 1...n.
For example, Given n = 3, your program should return all 5 unique BSTs shown below.
R
j
j
k
R
$
f
f
f $
$
j
k
R
R
j
k
f
f
$
$
k
R
k
j
ff G22i*Q/2- lMB[m2 "BM `v a2 `+? h`22b AA
ff
hP.P
hP.P
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ih`22LQ/2 = ;2M2` i2h`22bUBMi MV &
B7 UM 44 yV `2im`M ;2M2` i2UR- yVc
`2im`M ;2M2` i2UR- MVc
'
T`Bp i2,
p2+iQ`Ih`22LQ/2 = ;2M2` i2UBMi bi `i- BMi 2M/V &
p2+iQ`Ih`22LQ/2 = bm#h`22c
B7 Ubi `i = 2M/V &
111
5.3
bm#h`22XTmb?n# +FUMmHHTi`Vc
`2im`M bm#h`22c
'c
'
'
7Q` UBMi F 4 bi `ic F I4 2M/c FYYV &
p2+iQ`Ih`22LQ/2 = H27iam#b 4 ;2M2` i2Ubi `i- F @ RVc
p2+iQ`Ih`22LQ/2 = `B;?iam#b 4 ;2M2` i2UF Y R- 2M/Vc
7Q` U miQ B , H27iam#bV &
7Q` U miQ D , `B;?iam#bV &
h`22LQ/2 MQ/2 4 M2r h`22LQ/2UFVc
MQ/2@=H27i 4 Bc
MQ/2@=`B;?i 4 Dc
bm#h`22XTmb?n# +FUMQ/2Vc
'
'
'
`2im`M bm#h`22c
Unique Binary Search Trees
5.3.1
5.3.3 Validate Binary Search Tree
Given a binary tree, determine if it is a valid binary search tree (BST).
Assume a BST is defined as follows:
The left subtree of a node contains only nodes with keys less than the nodes key.
The right subtree of a node contains only nodes with keys greater than the nodes key.
Both the left and right subtrees must also be binary search trees.
ff G22i*Q/2- o HB/ i2 "BM `v a2 `+? h`22
ff
PUMV
PU$HQ;MV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bbo HB/"ahUh`22LQ/2 `QQiV &
`2im`M Bbo HB/"ahU`QQi- ALhnJAL- ALhnJsVc
'
#QQH Bbo HB/"ahUh`22LQ/2 `QQi- BMi HQr2`- BMi mTT2`V &
B7 U`QQi 44 MmHHTi`V `2im`M i`m2c
112
'c
'
`2im`M `QQi@=p H = HQr2` `QQi@=p H I mTT2`
Bbo HB/"ahU`QQi@=H27i- HQr2`- `QQi@=p HV
Bbo HB/"ahU`QQi@=`B;?i- `QQi@=p H- mTT2`Vc
Validate Binary Search Tree
5.3.3
5.3.4 Convert Sorted Array to Binary Search Tree
Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
ff G22i*Q/2- *QMp2`i aQ`i2/ `` v iQ "BM `v a2 `+? h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
h`22LQ/2 bQ`i2/`` vhQ"ah Up2+iQ`IBMi= MmKV &
`2im`M bQ`i2/`` vhQ"ahUMmKX#2;BMUV- MmKX2M/UVVc
'
i2KTH i2IivT2M K2 _ M/QK++2bbAi2` iQ`=
h`22LQ/2 bQ`i2/`` vhQ"ah U_ M/QK++2bbAi2` iQ` 7B`bi_ M/QK++2bbAi2` iQ` H biV &
+QMbi miQ H2M;i? 4 /Bbi M+2U7B`bi- H biVc
B7 UH2M;i? I4 yV `2im`M MmHHTi`c
ff
ff
miQ KB/ 4 7B`bi Y H2M;i? f kc
h`22LQ/2 `QQi 4 M2r h`22LQ/2 U KB/Vc
`QQi@=H27i 4 bQ`i2/`` vhQ"ahU7B`bi- KB/Vc
`QQi@=`B;?i 4 bQ`i2/`` vhQ"ahUKB/ Y R- H biVc
'c
'
`2im`M `QQic
113
5.3
Convert Sorted List to Binary Search Tree
5.3.5
5.3.5 Convert Sorted List to Binary Search Tree
Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced
BST.
RandomAccessIt-
erator
http://leetcode.com/2010/11/convert-sorted-list-to-balanced-
(bottom-up)
binary.html
Convert Sorted Array to Binary Search Tree
O(n log n)
ff G22i*Q/2- *QMp2`i aQ`i2/ GBbi iQ "BM `v a2 `+? h`22
ff
*QMp2`i aQ`i2/ `` v iQ "BM `v a2 `+? h`22
ff
PUM kV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
h`22LQ/2 bQ`i2/GBbihQ"ah UGBbiLQ/2 ?2 /V &
`2im`M bQ`i2/GBbihQ"ah U?2 /- HBbiG2M;i? U?2 /VVc
'
h`22LQ/2 bQ`i2/GBbihQ"ah UGBbiLQ/2 ?2 /- BMi H2MV &
B7 UH2M 44 yV `2im`M MmHHTi`c
B7 UH2M 44 RV `2im`M M2r h`22LQ/2 U?2 /@=p HVc
h`22LQ/2 `QQi 4 M2r h`22LQ/2 UMi?nMQ/2 U?2 /- H2M f k Y RV@=p HVc
`QQi@=H27i 4 bQ`i2/GBbihQ"ah U?2 /- H2M f kVc
`QQi@=`B;?i 4 bQ`i2/GBbihQ"ah UMi?nMQ/2 U?2 /- H2M f k Y kVUH2M @ RV f kVc
'
`2im`M `QQic
BMi HBbiG2M;i? UGBbiLQ/2
BMi M 4 yc
r?BH2UMQ/2V &
YYMc
MQ/2 4 MQ/2@=M2tic
MQ/2V &
114
5
'
'
`2im`M Mc
GBbiLQ/2 Mi?nMQ/2 UGBbiLQ/2
r?BH2 U@@MV
MQ/2 4 MQ/2@=M2tic
'c
'
MQ/2- BMi MV &
`2im`M MQ/2c
ff G22i*Q/2- *QMp2`i aQ`i2/ GBbi iQ "BM `v a2 `+? h`22
ff #QiiQK@mT
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
h`22LQ/2 bQ`i2/GBbihQ"ahUGBbiLQ/2 ?2 /V &
BMi H2M 4 yc
GBbiLQ/2 T 4 ?2 /c
r?BH2 UTV &
H2MYYc
T 4 T@=M2tic
'
`2im`M bQ`i2/GBbihQ"ahU?2 /- y- H2M @ RVc
'
T`Bp i2,
h`22LQ/2 bQ`i2/GBbihQ"ahUGBbiLQ/2 HBbi- BMi bi `i- BMi 2M/V &
B7 Ubi `i = 2M/V `2im`M MmHHTi`c
'c
'
BMi KB/ 4 bi `i Y U2M/ @ bi `iV f kc
h`22LQ/2 H27i*?BH/ 4 bQ`i2/GBbihQ"ahUHBbi- bi `i- KB/ @ RVc
h`22LQ/2 T `2Mi 4 M2r h`22LQ/2UHBbi@=p HVc
T `2Mi@=H27i 4 H27i*?BH/c
HBbi 4 HBbi@=M2tic
T `2Mi@=`B;?i 4 bQ`i2/GBbihQ"ahUHBbi- KB/ Y R- 2M/Vc
`2im`M T `2Mic
Convert Sorted Array to Binary Search Tree
5.4
5.3.4
115
5.4
10.12.5
DFS
3
3! = 6
`QQi@=`@=H
`@=`QQi@=H- `@=H@=`QQi
5.4.1 Minimum Depth of Binary Tree
Given a binary tree, find its minimum depth.
The minimum depth is the number of nodes along the shortest path from the root node down to the nearest
leaf node.
ff G22i*Q/2- JBMBKmK .2Ti? Q7 "BM `v h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi KBM.2Ti?U+QMbi h`22LQ/2 `QQiV &
`2im`M KBM.2Ti?U`QQi- 7 Hb2Vc
'
T`Bp i2,
bi iB+ BMi KBM.2Ti?U+QMbi h`22LQ/2 `QQi- #QQH ? b#`Qi?2`V &
B7 U5`QQiV `2im`M ? b#`Qi?2` \ ALhnJs , yc
'c
'
`2im`M R Y KBMUKBM.2Ti?U`QQi@=H27i- `QQi@=`B;?i 54 LlGGVKBM.2Ti?U`QQi@=`B;?i- `QQi@=H27i 54 LlGGVVc
ff G22i*Q/2- JBMBKmK .2Ti? Q7 "BM `v h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi KBM.2Ti?Uh`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V
`2im`M yc
BMi `2bmHi 4 ALhnJsc
bi +FIT B`Ih`22LQ/2 - BMi== bc
116
5
bXTmb?UK F2nT B`U`QQi- RVVc
r?BH2 U5bX2KTivUVV &
miQ MQ/2 4 bXiQTUVX7B`bic
miQ /2Ti? 4 bXiQTUVXb2+QM/c
bXTQTUVc
B7 UMQ/2@=H27i 44 MmHHTi` MQ/2@=`B;?i 44 MmHHTi`V
`2bmHi 4 KBMU`2bmHi- /2Ti?Vc
B7 UMQ/2@=H27i `2bmHi = /2Ti?V ff
bXTmb?UK F2nT B`UMQ/2@=H27i- /2Ti? Y RVVc
'
'c
'
B7 UMQ/2@=`B;?i `2bmHi = /2Ti?V ff
bXTmb?UK F2nT B`UMQ/2@=`B;?i- /2Ti? Y RVVc
`2im`M `2bmHic
Maximum Depth of Binary Tree
5.4.2
5.4.2 Maximum Depth of Binary Tree
Given a binary tree, find its maximum depth.
The maximum depth is the number of nodes along the longest path from the root node down to the
farthest leaf node.
ff G22i*Q/2- J tBKmK .2Ti? Q7 "BM `v h`22
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi K t.2Ti?Uh`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`M yc
'c
'
`2im`M K tUK t.2Ti?U`QQi@=H27iV- K t.2Ti?U`QQi@=`B;?iVV Y Rc
117
5.4
Minimum Depth of Binary Tree
5.4.1
5.4.3 Path Sum
Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the
values along the path equals the given sum.
For example: Given the below binary tree and bmK 4 kk,
8
f $
9
3
f
f $
RR Rj 9
f $
$
d
k
R
return true, as there exist a root-to-leaf path 8@=9@=RR@=k which sum is 22.
i`m2
7 Hb2
return
ff G22i*Q/2- S i? amK
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
#QQH ? bS i?amKUh`22LQ/2 `QQi- BMi bmKV &
B7 U`QQi 44 MmHHTi`V `2im`M 7 Hb2c
B7 U`QQi@=H27i 44 MmHHTi` `QQi@=`B;?i 44 MmHHTi`V ff H2 7
`2im`M bmK 44 `QQi@=p Hc
'c
'
`2im`M ? bS i?amKU`QQi@=H27i- bmK @ `QQi@=p HV
%% ? bS i?amKU`QQi@=`B;?i- bmK @ `QQi@=p HVc
Path Sum II
5.4.4
118
5.4.4 Path Sum II
Given a binary tree and a sum, find all root-to-leaf paths where each paths sum equals the given sum.
For example: Given the below binary tree and bmK 4 kk,
8
f $
9
3
f
f $
RR Rj 9
f $
f $
d
k 8
R
return
(
)
(8-9-RR-k)(8-3-9-8)
ff G22i*Q/2- S i? amK AA
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = T i?amKUh`22LQ/2 `QQi- BMi bmKV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`IBMi= +m`c ff
T i?amKU`QQi- bmK- +m`- `2bmHiVc
`2im`M `2bmHic
'
T`Bp i2,
pQB/ T i?amKUh`22LQ/2 `QQi- BMi ; T- p2+iQ`IBMi= +m`p2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 U`QQi 44 MmHHTi`V `2im`Mc
+m`XTmb?n# +FU`QQi@=p HVc
B7 U`QQi@=H27i 44 MmHHTi` `QQi@=`B;?i 44 MmHHTi`V & ff H2 7
B7 U; T 44 `QQi@=p HV
`2bmHiXTmb?n# +FU+m`Vc
'
T i?amKU`QQi@=H27i- ; T @ `QQi@=p H- +m`- `2bmHiVc
T i?amKU`QQi@=`B;?i- ; T @ `QQi@=p H- +m`- `2bmHiVc
return
119
5.4
'
'c
+m`XTQTn# +FUVc
Path Sum
5.4.3
5.4.5 Binary Tree Maximum Path Sum
Given a binary tree, find the maximum path sum.
The path may start and end at any node in the tree. For example: Given the below binary tree,
R
f $
k
j
Return 6.
13.2
Array
Binary Tree
Array
Binary Tree
dfs
L
L
R
ff G22i*Q/2- "BM `v h`22 J tBKmK S i? amK
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tS i?amKUh`22LQ/2 `QQiV &
K tnbmK 4 ALhnJALc
/7bU`QQiVc
`2im`M K tnbmKc
'
T`Bp i2,
BMi K tnbmKc
BMi /7bU+QMbi h`22LQ/2 `QQiV &
B7 U`QQi 44 MmHHTi`V `2im`M yc
BMi H 4 /7bU`QQi@=H27iVc
BMi ` 4 /7bU`QQi@=`B;?iVc
Binary Tree
L
0
R
120
'c
BMi bmK 4 `QQi@=p Hc
B7 UH = yV bmK Y4 Hc
B7 U` = yV bmK Y4 `c
K tnbmK 4 K tUK tnbmK- bmKVc
`2im`M K tU`- HV = y \ K tU`- HV Y `QQi@=p H , `QQi@=p Hc
'
return
L->root->R
L->root
R->root
Maximum Subarray
13.2
5.4.6 Populating Next Right Pointers in Each Node
Given a binary tree
bi`m+i h`22GBMFLQ/2 &
BMi p Hc
h`22GBMFLQ/2 H27i- `B;?i- M2tic
h`22GBMFLQ/2UBMi tV , p HUtV- H27iULlGGV- `B;?iULlGGV- M2tiULlGGV &'
'c
Populate each next pointer to point to its next right node. If there is no next right node, the next pointer
should be set to LlGG.
Initially, all next pointers are set to LlGG.
Note:
You may only use constant extra space.
You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent
has two children).
For example, Given the following perfect binary tree,
R
$
k
j
f $ f $
9 8 e d
f
After calling your function, the tree should look like:
R @= LlGG
f $
k @= j @= LlGG
f $ f $
9@=8@=e@=d @= LlGG
121
5.4
ff G22i*Q/2- SQTmH iBM; L2ti _B;?i SQBMi2`b BM 1 +? LQ/2
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ +QMM2+iUh`22GBMFLQ/2 `QQiV &
+QMM2+iU`QQi- LlGGVc
'
T`Bp i2,
pQB/ +QMM2+iUh`22GBMFLQ/2 `QQi- h`22GBMFLQ/2 bB#HBM;V &
B7 U`QQi 44 MmHHTi`V
`2im`Mc
2Hb2
`QQi@=M2ti 4 bB#HBM;c
'c
'
+QMM2+iU`QQi@=H27i- `QQi@=`B;?iVc
B7 UbB#HBM;V
+QMM2+iU`QQi@=`B;?i- bB#HBM;@=H27iVc
2Hb2
+QMM2+iU`QQi@=`B;?i- MmHHTi`Vc
Populating Next Right Pointers in Each Node II
5.1.12
5.4.7 Sum Root to Leaf Numbers
Given a binary tree containing digits from y@N only, each root-to-leaf path could represent a number.
An example is the root-to-leaf path R@=k@=j which represents the number Rkj.
Find the total sum of all root-to-leaf numbers.
For example,
R
f $
k
j
The root-to-leaf path R@=k represents the number Rk. The root-to-leaf path R@=j represents the number
Rj.
Return the sum = Rk Y Rj 4 k8.
122
ff G22i*Q/2- .2+Q/2 q vb
ff
PUMV
PUHQ;MV
+H bb aQHmiBQM &
Tm#HB+,
BMi bmKLmK#2`bUh`22LQ/2 `QQiV &
`2im`M /7bU`QQi- yVc
'
T`Bp i2,
BMi /7bUh`22LQ/2 `QQi- BMi bmKV &
B7 U`QQi 44 MmHHTi`V `2im`M yc
B7 U`QQi@=H27i 44 MmHHTi` `QQi@=`B;?i 44 MmHHTi`V
`2im`M bmK
Ry Y `QQi@=p Hc
'c
'
`2im`M /7bU`QQi@=H27i- bmK
Ry Y `QQi@=p HV Y
/7bU`QQi@=`B;?i- bmK
Ry Y `QQi@=p HVc
6.1 Merge Sorted Array
Given two sorted integer arrays A and B, merge B into A as one sorted array.
Note: You may assume that A has enough space to hold additional elements from B. The number of
elements initialized in A and B are m and n respectively.
ffG22i*Q/2- J2`;2 aQ`i2/ `` v
ff
PUKYMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ K2`;2Up2+iQ`IBMi= - BMi K- p2+iQ`IBMi= "- BMi MV &
BMi B 4 K @ R- B# 4 M @ R- B+m` 4 K Y M @ Rc
r?BH2UB =4 y B# =4 yV &
(B+m`@@) 4 (B ) =4 "(B#) \ (B @@) , "(B#@@)c
'
r?BH2UB# =4 yV &
(B+m`@@) 4 "(B#@@)c
'
'
'c
Merge Two Sorted Lists
Merge k Sorted Lists
6.2
6.3
123
124
6.2 Merge Two Sorted Lists
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together
the nodes of the first two lists.
ffG22i*Q/2- J2`;2 hrQ aQ`i2/ GBbib
ff
PUKBMUK-MVV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 K2`;2hrQGBbibUGBbiLQ/2 HR- GBbiLQ/2 HkV &
B7 UHR 44 MmHHTi`V `2im`M Hkc
B7 UHk 44 MmHHTi`V `2im`M HRc
GBbiLQ/2 /mKKvU@RVc
GBbiLQ/2 T 4 /mKKvc
7Q` Uc HR 54 MmHHTi` Hk 54 MmHHTi`c T 4 T@=M2tiV &
B7 UHR@=p H = Hk@=p HV & T@=M2ti 4 Hkc Hk 4 Hk@=M2tic '
2Hb2 & T@=M2ti 4 HRc HR 4 HR@=M2tic '
'
T@=M2ti 4 HR 54 MmHHTi` \ HR , Hkc
`2im`M /mKKvXM2tic
'
'c
Merge Sorted Array 6.1
Merge k Sorted Lists
6.3
6.3 Merge k Sorted Lists
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
Merge Two Sorted Lists
6.2
125
6.4 Insertion Sort List
ffG22i*Q/2- J2`;2 F aQ`i2/ GBbib
ff
PUMRYMkYXXXV
PURV
ff hP.P,
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 K2`;2EGBbibUp2+iQ`IGBbiLQ/2 = HBbibV &
B7 UHBbibXbBx2UV 44 yV `2im`M MmHHTi`c
'
'c
GBbiLQ/2 T 4 HBbib(y)c
7Q` UBMi B 4 Rc B I HBbibXbBx2UVc BYYV &
T 4 K2`;2hrQGBbibUT- HBbib(B)Vc
'
`2im`M Tc
ff J2`;2 hrQ aQ`i2/ GBbib
GBbiLQ/2 K2`;2hrQGBbibUGBbiLQ/2 HR- GBbiLQ/2 HkV &
GBbiLQ/2 ?2 /U@RVc
7Q` UGBbiLQ/2 T 4 ?2 /c HR 54 MmHHTi` %% Hk 54 MmHHTi`c T 4 T@=M2tiV &
BMi p HR 4 HR 44 MmHHTi` \ ALhnJs , HR@=p Hc
BMi p Hk 4 Hk 44 MmHHTi` \ ALhnJs , Hk@=p Hc
B7 Up HR I4 p HkV &
T@=M2ti 4 HRc
HR 4 HR@=M2tic
' 2Hb2 &
T@=M2ti 4 Hkc
Hk 4 Hk@=M2tic
'
'
`2im`M ?2 /XM2tic
'
Merge Sorted Array 6.1
Merge Two Sorted Lists
6.2
6.4 Insertion Sort List
Sort a linked list using insertion sort.
126
ff G22i*Q/2- AMb2`iBQM aQ`i GBbi
ff
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
GBbiLQ/2 BMb2`iBQMaQ`iGBbiUGBbiLQ/2
GBbiLQ/2 /mKKvUALhnJALVc
ff/mKKvXM2ti 4 ?2 /c
'
'c
?2 /V &
7Q` UGBbiLQ/2 +m` 4 ?2 /c +m` 54 MmHHTi`cV &
miQ TQb 4 7BM/AMb2`iSQbU /mKKv- +m`@=p HVc
GBbiLQ/2 iKT 4 +m`@=M2tic
+m`@=M2ti 4 TQb@=M2tic
TQb@=M2ti 4 +m`c
+m` 4 iKTc
'
`2im`M /mKKvXM2tic
GBbiLQ/2 7BM/AMb2`iSQbUGBbiLQ/2 ?2 /- BMi tV &
GBbiLQ/2 T`2 4 MmHHTi`c
7Q` UGBbiLQ/2 +m` 4 ?2 /c +m` 54 MmHHTi` +m`@=p H I4 tc
T`2 4 +m`- +m` 4 +m`@=M2tiV
c
`2im`M T`2c
'
Sort List,
6.5
6.5 Sort List
Sort a linked list in O(nlogn) time using constant space complexity.
O(nlogn)
Two Sorted Lists
ff G22i*Q/2- aQ`i GBbi
ff
PUMHQ;MV
+H bb aQHmiBQM &
PURV
Merge
127
6.6 First Missing Positive
Tm#HB+,
GBbiLQ/2 bQ`iGBbiUGBbiLQ/2 ?2 /V &
B7 U?2 / 44 LlGG %% ?2 /@=M2ti 44 LlGGV`2im`M ?2 /c
ff
GBbiLQ/2 7 bi 4 ?2 /- bHQr 4 ?2 /c
r?BH2 U7 bi@=M2ti 54 LlGG 7 bi@=M2ti@=M2ti 54 LlGGV &
7 bi 4 7 bi@=M2ti@=M2tic
bHQr 4 bHQr@=M2tic
'
ff
7 bi 4 bHQrc
bHQr 4 bHQr@=M2tic
7 bi@=M2ti 4 LlGGc
'
'c
GBbiLQ/2 HR 4 bQ`iGBbiU?2 /Vc
GBbiLQ/2 Hk 4 bQ`iGBbiUbHQrVc
`2im`M K2`;2hrQGBbibUHR- HkVc
ff
ff
ff J2`;2 hrQ aQ`i2/ GBbib
GBbiLQ/2 K2`;2hrQGBbibUGBbiLQ/2 HR- GBbiLQ/2 HkV &
GBbiLQ/2 /mKKvU@RVc
7Q` UGBbiLQ/2 T 4 /mKKvc HR 54 MmHHTi` %% Hk 54 MmHHTi`c T 4 T@=M2tiV &
BMi p HR 4 HR 44 MmHHTi` \ ALhnJs , HR@=p Hc
BMi p Hk 4 Hk 44 MmHHTi` \ ALhnJs , Hk@=p Hc
B7 Up HR I4 p HkV &
T@=M2ti 4 HRc
HR 4 HR@=M2tic
' 2Hb2 &
T@=M2ti 4 Hkc
Hk 4 Hk@=M2tic
'
'
`2im`M /mKKvXM2tic
'
Insertion Sort List
6.4
6.6 First Missing Positive
Given an unsorted integer array, find the first missing positive integer.
For example, Given (R-k-y) return j, and (j-9-@R-R) return k.
Your algorithm should run in O(n) time and uses constant space.
128
(bucket sort)
(B)54 BYR
A[i]
A[A[i]-1]
(B)44 ((B)@R)
ff G22i*Q/2- 6B`bi JBbbBM; SQbBiBp2
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi 7B`biJBbbBM;SQbBiBp2Up2+iQ`IBMi= MmKbV &
#m+F2inbQ`iUMmKbVc
7Q` UBMi B 4 yc B I MmKbXbBx2UVc YYBV
B7 UMmKb(B) 54 UB Y RVV
`2im`M B Y Rc
`2im`M MmKbXbBx2UV Y Rc
'
T`Bp i2,
bi iB+ pQB/ #m+F2inbQ`iUp2+iQ`IBMi= V &
+QMbi BMi M 4 XbBx2UVc
7Q` UBMi B 4 yc B I Mc BYYV &
r?BH2 U(B) 54 B Y RV &
B7 U(B) I4 y %% (B) = M %% (B) 44 ((B) @ R)V
#`2 Fc
br TU(B)- ((B) @ R)Vc
'
'
'
'c
Sort Colors,
6.7
6.7 Sort Colors
Given an array with n objects colored red, white or blue, sort them so that objects of the same color are
adjacent, with the colors in the order red, white and blue.
Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
Note: You are not suppose to use the librarys sort function for this problem.
Follow up:
A rather straight forward solution is a two-pass algorithm using counting sort.
129
6.7 Sort Colors
First, iterate the array counting number of 0s, 1s, and 2s, then overwrite array with total number of 0s,
then 1s and followed by 2s.
Could you come up with an one-pass algorithm using only constant space?
0, 1, 2
(counting sort)
index
O(n)
red
index
index
O(1)
partition
1
ff G22i*Q/2- aQ`i *QHQ`b
ff *QmMiBM; aQ`i
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ bQ`i*QHQ`bUp2+iQ`IBMi= V &
BMi +QmMib(j) 4 & y 'c ff
7Q` UBMi B 4 yc B I XbBx2UVc BYYV
+QmMib((B))YYc
7Q` UBMi B 4 y- BM/2t 4 yc B I jc BYYV
7Q` UBMi D 4 yc D I +QmMib(B)c DYYV
(BM/2tYY) 4 Bc
'c
blue
'
2
ff G22i*Q/2- aQ`i *QHQ`b
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ bQ`i*QHQ`bUp2+iQ`IBMi= V &
ff
`2/
BM/2t
#Hm2
BMi `2/ 4 y- #Hm2 4 XbBx2UV @ Rc
7Q` UBMi B 4 yc B I #Hm2 Y RcV &
B7 U(B) 44 yV
br TU(BYY)- (`2/YY)Vc
2Hb2 B7 U(B) 44 kV
br TU(B)- (#Hm2@@)Vc
2Hb2
BM/2t
130
'c
'
'
BYYc
3
ff G22i*Q/2- aQ`i *QHQ`b
ff mb2 T `iBiBQMUV
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ bQ`i*QHQ`bUp2+iQ`IBMi= MmKbV &
T `iBiBQMUT `iBiBQMUMmKbX#2;BMUV- MmKbX2M/UV- #BM/RbiU2[m HniQIBMi=UV- yVVMmKbX2M/UV- #BM/RbiU2[m HniQIBMi=UV- RVVc
'
'c
4
ff G22i*Q/2- aQ`i *QHQ`b
ff
T `iBiBQMUV
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ bQ`i*QHQ`bUp2+iQ`IBMi= MmKbV &
T `iBiBQMUT `iBiBQMUMmKbX#2;BMUV- MmKbX2M/UV- #BM/RbiU2[m HniQIBMi=UV- yVVMmKbX2M/UV- #BM/RbiU2[m HniQIBMi=UV- RVVc
'
T`Bp i2,
i2KTH i2IivT2M K2 6Q`r `/Ai2` iQ`- ivT2M K2 lM `vS`2/B+ i2=
6Q`r `/Ai2` iQ` T `iBiBQMU6Q`r `/Ai2` iQ` 7B`bi- 6Q`r `/Ai2` iQ` H bilM `vS`2/B+ i2 T`2/V &
miQ TQb 4 7B`bic
7Q` Uc 7B`bi 54 H bic YY7B`biV
B7 UT`2/U 7B`biVV
br TU 7B`bi- TQbYYVc
'c
'
`2im`M TQbc
First Missing Positive,
6.6
7.1 Search for a Range
Given a sorted array of integers, find the starting and ending position of a given target value.
Your algorithms runtime complexity must be in the order of O(log n).
If the target is not found in the array, return (@R- @R).
For example, Given (8- d- d- 3- 3- Ry) and target value 8, return (j- 9).
STL
ff G22i*Q/2- a2 `+? 7Q` _ M;2
ff
ahG
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= b2 `+?_ M;2Up2+iQ`IBMi= MmKb- BMi i `;2iV &
+QMbi BMi H 4 /Bbi M+2UMmKbX#2;BMUV- HQr2`n#QmM/UMmKbX#2;BMUV- MmKbX2M/UV- i `;2iVVc
+QMbi BMi m 4 /Bbi M+2UMmKbX#2;BMUV- T`2pUmTT2`n#QmM/UMmKbX#2;BMUV- MmKbX2M/UV- i `;2i
B7 UMmKb(H) 54 i `;2iV ff MQi 7QmM/
`2im`M p2+iQ`IBMi= & @R- @R 'c
2Hb2
`2im`M p2+iQ`IBMi= & H- m 'c
'
'c
lower_bound
upper_bound
ff G22i*Q/2- a2 `+? 7Q` _ M;2
ff
HQr2`n#QmM/
mTT2`n#QmM/
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
131
132
Tm#HB+,
p2+iQ`IBMi= b2 `+?_ M;2 Up2+iQ`IBMi= MmKb- BMi i `;2iV &
miQ HQr2` 4 HQr2`n#QmM/UMmKbX#2;BMUV- MmKbX2M/UV- i `;2iVc
miQ mTTT2` 4 mTT2`n#QmM/UHQr2`- MmKbX2M/UV- i `;2iVc
'
B7 UHQr2` 44 MmKbX2M/UV %% HQr2` 54 i `;2iV
`2im`M p2+iQ`IBMi= & @R- @R 'c
2Hb2
`2im`M p2+iQ`IBMi= &/Bbi M+2UMmKbX#2;BMUV- HQr2`V- /Bbi M+2UMmKbX#2;BMUV- T`2pUmTT
i2KTH i2IivT2M K2 6Q`r `/Ai2` iQ`- ivT2M K2 h=
6Q`r `/Ai2` iQ` HQr2`n#QmM/ U6Q`r `/Ai2` iQ` 7B`bi6Q`r `/Ai2` iQ` H bi- h p Hm2V &
r?BH2 U7B`bi 54 H biV &
miQ KB/ 4 M2tiU7B`bi- /Bbi M+2U7B`bi- H biV f kVc
'
'
B7 Up Hm2 =
2Hb2
KB/V
7B`bi 4 YYKB/c
H bi 4 KB/c
`2im`M 7B`bic
i2KTH i2IivT2M K2 6Q`r `/Ai2` iQ`- ivT2M K2 h=
6Q`r `/Ai2` iQ` mTT2`n#QmM/ U6Q`r `/Ai2` iQ` 7B`bi6Q`r `/Ai2` iQ` H bi- h p Hm2V &
r?BH2 U7B`bi 54 H biV &
miQ KB/ 4 M2tiU7B`bi- /Bbi M+2 U7B`bi- H biV f kVc
'
'c
'
B7 Up Hm2 =4
2Hb2
KB/V
7B`bi 4 YYKB/c
H bi 4 KB/c
ff
HQr2`n#QmM/
`2im`M 7B`bic
Search Insert Position,
7.2
7.2 Search Insert Position
Given a sorted array and a target value, return the index if the target is found. If not, return the index
where it would be if it were inserted in order.
You may assume no duplicates in the array.
133
7.3 Search a 2D Matrix
Here are few examples.
(R-j-8-e)- 8 k
(R-j-8-e)- k R
(R-j-8-e)- d 9
(R-j-8-e)- y y
bi/,,HQr2`n#QmM/UV
ff G22i*Q/2- a2 `+? AMb2`i SQbBiBQM
ff
HQr2`n#QmM/
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi b2 `+?AMb2`iUp2+iQ`IBMi= MmKb- BMi i `;2iV &
`2im`M /Bbi M+2UMmKbX#2;BMUV- HQr2`n#QmM/UMmKbX#2;BMUV- MmKbX2M/UV- i `;2iVVc
'
i2KTH i2IivT2M K2 6Q`r `/Ai2` iQ`- ivT2M K2 h=
6Q`r `/Ai2` iQ` HQr2`n#QmM/ U6Q`r `/Ai2` iQ` 7B`bi6Q`r `/Ai2` iQ` H bi- h p Hm2V &
r?BH2 U7B`bi 54 H biV &
miQ KB/ 4 M2tiU7B`bi- /Bbi M+2U7B`bi- H biV f kVc
'
'c
'
B7 Up Hm2 =
2Hb2
KB/V
7B`bi 4 YYKB/c
H bi 4 KB/c
`2im`M 7B`bic
Search for a Range,
7.1
7.3 Search a 2D Matrix
Write an efficient algorithm that searches for a value in an m n matrix. This matrix has the following
properties:
Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.
134
7
For example, Consider the following matrix:
(Rj- 8- d)(Ry- RR- Re- ky)(kj- jy- j9- 8y)
Given i `;2i 4 j, return true.
ff G22i*Q/2- a2 `+? k. J i`Bt
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH b2 `+?J i`BtU+QMbi p2+iQ`Ip2+iQ`IBMi== K i`Bt- BMi i `;2iV &
B7 UK i`BtX2KTivUVV `2im`M 7 Hb2c
+QMbi bBx2ni K 4 K i`BtXbBx2UVc
+QMbi bBx2ni M 4 K i`BtX7`QMiUVXbBx2UVc
BMi 7B`bi 4 yc
BMi H bi 4 K
Mc
r?BH2 U7B`bi I H biV &
BMi KB/ 4 7B`bi Y UH bi @ 7B`biV f kc
BMi p Hm2 4 K i`Bt(KB/ f M)(KB/ W M)c
'
'c
'
B7 Up Hm2 44 i `;2iV
`2im`M i`m2c
2Hb2 B7 Up Hm2 I i `;2iV
7B`bi 4 KB/ Y Rc
2Hb2
H bi 4 KB/c
`2im`M 7 Hb2c
8.1 Subsets
Given a set of distinct integers, S, return all possible subsets.
Note:
Elements in a subset must be in non-descending order.
The solution set must not contain duplicate subsets.
For example, If a 4 (R-k-j), a solution is:
(
(j)(R)(k)(R-k-j)(R-j)(k-j)(R-k)()
8.1.1
ff G22i*Q/2- am#b2ib
ff
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`IBMi= T i?c
bm#b2ibUa- T i?- y- `2bmHiVc
`2im`M `2bmHic
135
136
8
'
T`Bp i2,
bi iB+ pQB/ bm#b2ibU+QMbi p2+iQ`IBMi= a- p2+iQ`IBMi= T i?- BMi bi2Tp2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 Ubi2T 44 aXbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
ff
a(bi2T)
bm#b2ibUa- T i?- bi2T Y R- `2bmHiVc
ff
a(bi2T)
T i?XTmb?n# +FUa(bi2T)Vc
bm#b2ibUa- T i?- bi2T Y R- `2bmHiVc
T i?XTQTn# +FUVc
'
'c
#QQH b2H2+i2/(M)
ff G22i*Q/2- am#b2ib
ff
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
'
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`I#QQH= b2H2+i2/UaXbBx2UV- 7 Hb2Vc
bm#b2ibUa- b2H2+i2/- y- `2bmHiVc
`2im`M `2bmHic
T`Bp i2,
bi iB+ pQB/ bm#b2ibU+QMbi p2+iQ`IBMi= a- p2+iQ`I#QQH= b2H2+i2/- BMi bi2Tp2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 Ubi2T 44 aXbBx2UVV &
p2+iQ`IBMi= bm#b2ic
7Q` UBMi B 4 yc B I aXbBx2UVc BYYV &
B7 Ub2H2+i2/(B)V bm#b2iXTmb?n# +FUa(B)Vc
'
`2bmHiXTmb?n# +FUbm#b2iVc
`2im`Mc
'
ff
a(bi2T)
b2H2+i2/(bi2T) 4 7 Hb2c
bm#b2ibUa- b2H2+i2/- bi2T Y R- `2bmHiVc
ff
a(bi2T)
b2H2+i2/(bi2T) 4 i`m2c
bm#b2ibUa- b2H2+i2/- bi2T Y R- `2bmHiVc
137
8.1 Subsets
'
'c
8.1.2
ff G22i*Q/2- am#b2ib
ff
PUk MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
p2+iQ`Ip2+iQ`IBMi= = `2bmHiURVc
7Q` U miQ 2H2K , aV &
`2bmHiX`2b2`p2U`2bmHiXbBx2UV
kVc
miQ ? H7 4 `2bmHiX#2;BMUV Y `2bmHiXbBx2UVc
+QTvU`2bmHiX#2;BMUV- ? H7- # +FnBMb2`i2`U`2bmHiVVc
7Q`n2 +?U? H7- `2bmHiX2M/UV- ( 2H2K)U/2+HivT2U`2bmHi(y)V 2V&
2XTmb?n# +FU2H2KVc
'Vc
'
`2im`M `2bmHic
'
'c
int
S[i]
a4&-"-*-.'
0
B1
B2
int
yRRy4e
B1 B2 , B1 B2 , B1 B2
ff G22i*Q/2- am#b2ib
ff
PUk MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
+QMbi bBx2ni M 4 aXbBx2UVc
p2+iQ`IBMi= pc
7Q` UbBx2ni B 4 yc B I R II Mc BYYV &
7Q` UbBx2ni D 4 yc D I Mc DYYV &
B7 UB R II DV pXTmb?n# +FUa(D)Vc
'
`2bmHiXTmb?n# +FUpVc
pX+H2 `UVc
i
&"-*'
138
'
'c
'
`2im`M `2bmHic
Subsets II
8.2
8.2 Subsets II
Given a collection of integers that might contain duplicates, S, return all possible subsets.
Note:
Elements in a subset must be in non-descending order. The solution set must not contain duplicate
subsets. For example, If a 4 (R-k-k), a solution is:
(
(k)(R)(R-k-k)(k-k)(R-k)()
8.2.1
ff G22i*Q/2- am#b2ib AA
ff
R
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibqBi?.mTUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`IBMi= T i?c
/7bUa- aX#2;BMUV- T i?- `2bmHiVc
8.2 Subsets II
'
`2im`M `2bmHic
T`Bp i2,
bi iB+ pQB/ /7bU+QMbi p2+iQ`IBMi= a- p2+iQ`IBMi=,,Bi2` iQ` bi `ip2+iQ`IBMi= T i?- p2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
`2bmHiXTmb?n# +FUT i?Vc
'c
'
7Q` U miQ B 4 bi `ic B I aX2M/UVc BYYV &
B7 UB 54 bi `i B 44 UB@RVV +QMiBMm2c
T i?XTmb?n# +FU BVc
/7bUa- B Y R- T i?- `2bmHiVc
T i?XTQTn# +FUVc
'
ff G22i*Q/2- am#b2ib AA
ff
k
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibqBi?.mTUp2+iQ`IBMi= aV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
bQ`iUaX#2;BMUV- aX2M/UVVc ff
mMQ`/2`2/nK TIBMi- BMi= +QmMinK Tc ff
7Q`n2 +?UaX#2;BMUV- aX2M/UV- ( +QmMinK T)UBMi 2V &
B7 U+QmMinK TX7BM/U2V 54 +QmMinK TX2M/UVV
+QmMinK T(2)YYc
2Hb2
+QmMinK T(2) 4 Rc
'Vc
ff
K T
T B`
p2+iQ`
p2+iQ`IT B`IBMi- BMi= = 2H2Kbc
7Q`n2 +?U+QmMinK TX#2;BMUV- +QmMinK TX2M/UV( 2H2Kb)U+QMbi T B`IBMi- BMi= 2V &
2H2KbXTmb?n# +FU2Vc
'Vc
bQ`iU2H2KbX#2;BMUV- 2H2KbX2M/UVVc
p2+iQ`IBMi= T i?c ff
'
bm#b2ibU2H2Kb- y- T i?- `2bmHiVc
`2im`M `2bmHic
T`Bp i2,
bi iB+ pQB/ bm#b2ibU+QMbi p2+iQ`IT B`IBMi- BMi= = 2H2KbbBx2ni bi2T- p2+iQ`IBMi= T i?- p2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 Ubi2T 44 2H2KbXbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
139
140
'c
'
7Q` UBMi B 4 yc B I4 2H2Kb(bi2T)Xb2+QM/c BYYV &
7Q` UBMi D 4 yc D I Bc YYDV &
T i?XTmb?n# +FU2H2Kb(bi2T)X7B`biVc
'
bm#b2ibU2H2Kb- bi2T Y R- T i?- `2bmHiVc
7Q` UBMi D 4 yc D I Bc YYDV &
T i?XTQTn# +FUVc
'
'
ff G22i*Q/2- am#b2ib AA
ff
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibqBi?.mTUp2+iQ`IBMi= aV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic ff
bQ`iUaX#2;BMUV- aX2M/UVVc
p2+iQ`IBMi= +QmMiUaX# +FUV @ aX7`QMiUV Y R- yVc
ff
7Q` U miQ B , aV &
+QmMi(B @ a(y))YYc
'
ff
p2+iQ`IBMi= b2H2+i2/UaX# +FUV @ aX7`QMiUV Y R- @RVc
'
bm#b2ibUa- +QmMi- b2H2+i2/- y- `2bmHiVc
`2im`M `2bmHic
T`Bp i2,
bi iB+ pQB/ bm#b2ibU+QMbi p2+iQ`IBMi= a- p2+iQ`IBMi= +QmMip2+iQ`IBMi= b2H2+i2/- bBx2ni bi2T- p2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 Ubi2T 44 +QmMiXbBx2UVV &
p2+iQ`IBMi= bm#b2ic
7Q`UbBx2ni B 4 yc B I b2H2+i2/XbBx2UVc BYYV &
7Q` UBMi D 4 yc D I b2H2+i2/(B)c DYYV &
bm#b2iXTmb?n# +FUBYa(y)Vc
'
'
`2bmHiXTmb?n# +FUbm#b2iVc
`2im`Mc
'
'
7Q` UBMi B 4 yc B I4 +QmMi(bi2T)c BYYV &
b2H2+i2/(bi2T) 4 Bc
bm#b2ibUa- +QmMi- b2H2+i2/- bi2T Y R- `2bmHiVc
'
8.2 Subsets II
'c
8.2.2
ff G22i*Q/2- am#b2ib AA
ff
ff
PUk MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibqBi?.mTUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
p2+iQ`Ip2+iQ`IBMi= = `2bmHiURVc
'c
'
bBx2ni T`2pBQmbnbBx2 4 yc
7Q` UbBx2ni B 4 yc B I aXbBx2UVc YYBV &
+QMbi bBx2ni bBx2 4 `2bmHiXbBx2UVc
7Q` UbBx2ni D 4 yc D I bBx2c YYDV &
B7 UB 44 y %% a(B) 54 a(B@R) %% D =4 T`2pBQmbnbBx2V &
`2bmHiXTmb?n# +FU`2bmHi(D)Vc
`2bmHiX# +FUVXTmb?n# +FUa(B)Vc
'
'
T`2pBQmbnbBx2 4 bBx2c
'
`2im`M `2bmHic
ff G22i*Q/2- am#b2ib AA
ff
PUk MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = bm#b2ibqBi?.mTUp2+iQ`IBMi= aV &
bQ`iUaX#2;BMUV- aX2M/UVVc ff
ff
b2i
mMQ`/2`2/nb2i
b2iIp2+iQ`IBMi= = `2bmHic
+QMbi bBx2ni M 4 aXbBx2UVc
p2+iQ`IBMi= pc
7Q` UbBx2ni B 4 yc B I Rl II Mc YYBV &
7Q` UbBx2ni D 4 yc D I Mc YYDV &
B7 UB R II DV
pXTmb?n# +FUa(D)Vc
'
`2bmHiXBMb2`iUpVc
pX+H2 `UVc
'
p2+iQ`Ip2+iQ`IBMi= = `2 Hn`2bmHic
141
142
'
'c
+QTvU`2bmHiX#2;BMUV- `2bmHiX2M/UV- # +FnBMb2`i2`U`2 Hn`2bmHiVVc
`2im`M `2 Hn`2bmHic
Subsets
8.1
8.3 Permutations
Given a collection of numbers, return all possible permutations.
For example, (R-k-j) have the following permutations: (R-k-j)- (R-j-k)- (k-R-j)- (k-j-R)(j-R-k), and (j-k-R).
8.3.1 next_permutation()
bi/,,M2tinT2`Kmi iBQMUV
OJ
ff G22i*Q/2- S2`Kmi iBQMb
ff
PUM5V
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = T2`Kmi2Up2+iQ`IBMi= MmKV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
bQ`iUMmKX#2;BMUV- MmKX2M/UVVc
/Q &
'c
'
`2bmHiXTmb?n# +FUMmKVc
' r?BH2UM2tinT2`Kmi iBQMUMmKX#2;BMUV- MmKX2M/UVVVc
`2im`M `2bmHic
8.3.2
next_permutation()
2.1.12
API
143
8.3 Permutations
ff G22i*Q/2- S2`Kmi iBQMb
ff
M2tinT2`Kmi iBQMUV
ff
PUM5V
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = T2`Kmi2Up2+iQ`IBMi= MmKV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
bQ`iUMmKX#2;BMUV- MmKX2M/UVVc
/Q &
'c
'
`2bmHiXTmb?n# +FUMmKVc
ff
kXRXRk
M2tinT2`Kmi iBQMUV
ff
bi/,,M2tinT2`Kmi iBQMUV
' r?BH2UM2tinT2`Kmi iBQMUMmKX#2;BMUV- MmKX2M/UVVVc
`2im`M `2bmHic
8.3.3
ff G22i*Q/2- S2`Kmi iBQMb
ff
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = T2`Kmi2Up2+iQ`IBMi= MmKV &
bQ`iUMmKX#2;BMUV- MmKX2M/UVVc
p2+iQ`Ip2+iQ`IBMi== `2bmHic
p2+iQ`IBMi= T i?c ff
/7bUMmK- T i?- `2bmHiVc
`2im`M `2bmHic
'
T`Bp i2,
pQB/ /7bU+QMbi p2+iQ`IBMi= MmK- p2+iQ`IBMi= T i?p2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 UT i?XbBx2UV 44 MmKXbBx2UVV & ff
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
144
ff
7Q` U miQ B , MmKV &
ff
B
T i?
miQ TQb 4 7BM/UT i?X#2;BMUV- T i?X2M/UV- BVc
'
'c
'
B7 UTQb 44 T i?X2M/UVV &
T i?XTmb?n# +FUBVc
/7bUMmK- T i?- `2bmHiVc
T i?XTQTn# +FUVc
'
Next Permutation,
2.1.12
Permutation Sequence,
Permutations II,
Combinations,
2.1.13
8.4
8.5
8.4 Permutations II
Given a collection of numbers that might contain duplicates, return all possible unique permutations.
For example, (R-R-k) have the following unique permutations: (R-R-k)- (R-k-R), and (k-R-R).
8.4.1 next_permutation()
bi/,,M2tinT2`Kmi iBQMUV
8.4.2
next_permutation()
bi/,,M2tinT2`Kmi iBQMUV
8.4.3
T2`Kmi2UV
8.4 Permutations II
ff G22i*Q/2- S2`Kmi iBQMb AA
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = T2`Kmi2lMB[m2Up2+iQ`IBMi= MmKV &
bQ`iUMmKX#2;BMUV- MmKX2M/UVVc
mMQ`/2`2/nK TIBMi- BMi= +QmMinK Tc ff
7Q`n2 +?UMmKX#2;BMUV- MmKX2M/UV- ( +QmMinK T)UBMi 2V &
B7 U+QmMinK TX7BM/U2V 54 +QmMinK TX2M/UVV
+QmMinK T(2)YYc
2Hb2
+QmMinK T(2) 4 Rc
'Vc
ff
K T
T B`
p2+iQ`
p2+iQ`IT B`IBMi- BMi= = 2H2Kbc
7Q`n2 +?U+QmMinK TX#2;BMUV- +QmMinK TX2M/UV( 2H2Kb)U+QMbi T B`IBMi- BMi= 2V &
2H2KbXTmb?n# +FU2Vc
'Vc
p2+iQ`Ip2+iQ`IBMi== `2bmHic ff
p2+iQ`IBMi= Tc ff
'
M 4 MmKXbBx2UVc
T2`Kmi2U2H2KbX#2;BMUV- 2H2KbX2M/UV- T- `2bmHiVc
`2im`M `2bmHic
T`Bp i2,
bBx2ni Mc
ivT2/27 p2+iQ`IT B`IBMi- BMi= =,,+QMbinBi2` iQ` Ai2`c
pQB/ T2`Kmi2UAi2` 7B`bi- Ai2` H bi- p2+iQ`IBMi= Tp2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 UM 44 TXbBx2UVV & ff
`2bmHiXTmb?n# +FUTVc
'
ff
7Q` U miQ B 4 7B`bic B 54 H bic BYYV &
BMi +QmMi 4 yc ff
B
T
7Q` U miQ D 4 TX#2;BMUVc D 54 TX2M/UVc DYYV &
B7 UB@=7B`bi 44 DV &
+QmMi YYc
'
'
B7 U+QmMi I B@=b2+QM/V &
TXTmb?n# +FUB@=7B`biVc
T2`Kmi2U7B`bi- H bi- T- `2bmHiVc
145
146
'
'c
'
'
TXTQTn# +FUVc ff
Next Permutation,
2.1.12
Permutation Sequence,
Permutations,
Combinations,
2.1.13
8.3
8.5
8.5 Combinations
Given two integers n and k, return all possible combinations of k numbers out of 1...n.
For example, If n = 4 and k = 2, a solution is:
(
(k-9)(j-9)(k-j)(R-k)(R-j)(R-9)-
8.5.1
ff G22i*Q/2- *QK#BM iBQMb
ff
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = +QK#BM2UBMi M- BMi FV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`IBMi= T i?c
/7bUM- F- R- y- T i?- `2bmHiVc
`2im`M `2bmHic
'
T`Bp i2,
ff bi `i
- +m`
bi iB+ pQB/ /7bUBMi M- BMi F- BMi bi `i- BMi +m`p2+iQ`IBMi= T i?- p2+iQ`Ip2+iQ`IBMi= = `2bmHiV &
B7 U+m` 44 FV &
`2bmHiXTmb?n# +FUT i?Vc
8.6 Letter Combinations of a Phone Number
'
'c
'
7Q` UBMi B 4 bi `ic B I4 Mc YYBV &
T i?XTmb?n# +FUBVc
/7bUM- F- B Y R- +m` Y R- T i?- `2bmHiVc
T i?XTQTn# +FUVc
'
8.5.2
ff G22i*Q/2- *QK#BM iBQMb
ff mb2 T`2pnT2`Kmi iBQMUV
ff
PUUM@FV5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = +QK#BM2UBMi M- BMi FV &
p2+iQ`IBMi= p Hm2bUMVc
BQi Up Hm2bX#2;BMUV- p Hm2bX2M/UV- RVc
p2+iQ`I#QQH= b2H2+iUM- 7 Hb2Vc
7BHHnMUb2H2+iX#2;BMUV- F- i`m2Vc
'c
'
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
/Q&
p2+iQ`IBMi= QM2UFVc
7Q` UBMi B 4 y- BM/2t 4 yc B I Mc YYBV
B7 Ub2H2+i(B)V
QM2(BM/2tYY) 4 p Hm2b(B)c
`2bmHiXTmb?n# +FUQM2Vc
' r?BH2UT`2pnT2`Kmi iBQMUb2H2+iX#2;BMUV- b2H2+iX2M/UVVVc
`2im`M `2bmHic
Next Permutation,
2.1.12
Permutation Sequence,
Permutations,
Permutations II,
2.1.13
8.3
8.4
8.6 Letter Combinations of a Phone Number
Given a digit string, return all possible letter combinations that the number could represent.
A mapping of digit to letters (just like on the telephone buttons) is given below.
147
148
8-1
Phone Keyboard
Input:Digit string ]kj]
Output: (] /]- ] 2]- ] 7]- ]#/]- ]#2]- ]#7]- ]+/]- ]+2]- ]+7]).
Note: Although the above answer is in lexicographical order, your answer could be in any order you
want.
8.6.1
ff G22i*Q/2- G2ii2` *QK#BM iBQMb Q7 S?QM2 LmK#2`
ff
PUj MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
+QMbi p2+iQ`Ibi`BM;= F2v#Q `/ & ] ]- ]]- ] #+]- ]/27]- ff ^y^-^R^-^k^-XXX
];?B]- ]DFH]- ]KMQ]- ]T[`b]- ]imp]- ]rtvx] 'c
p2+iQ`Ibi`BM;= H2ii2`*QK#BM iBQMb U+QMbi bi`BM; /B;BibV &
p2+iQ`Ibi`BM;= `2bmHic
B7 U/B;BibX2KTivUVV `2im`M `2bmHic
/7bU/B;Bib- y- ]]- `2bmHiVc
`2im`M `2bmHic
'
pQB/ /7bU+QMbi bi`BM; /B;Bib- bBx2ni +m`- bi`BM; T i?p2+iQ`Ibi`BM;= `2bmHiV &
B7 U+m` 44 /B;BibXbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
7Q` U miQ + , F2v#Q `/(/B;Bib(+m`) @ ^y^)V &
/7bU/B;Bib- +m` Y R- T i? Y +- `2bmHiVc
'
149
8.6 Letter Combinations of a Phone Number
'
'c
8.6.2
ff G22i*Q/2- G2ii2` *QK#BM iBQMb Q7 S?QM2 LmK#2`
ff
PUj MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
+QMbi p2+iQ`Ibi`BM;= F2v#Q `/ & ] ]- ]]- ] #+]- ]/27]- ff ^y^-^R^-^k^-XXX
];?B]- ]DFH]- ]KMQ]- ]T[`b]- ]imp]- ]rtvx] 'c
p2+iQ`Ibi`BM;= H2ii2`*QK#BM iBQMb U+QMbi bi`BM; /B;BibV &
B7 U/B;BibX2KTivUVV `2im`M p2+iQ`Ibi`BM;=UVc
p2+iQ`Ibi`BM;= `2bmHiUR- ]]Vc
7Q` U miQ / , /B;BibV &
+QMbi bBx2ni M 4 `2bmHiXbBx2UVc
+QMbi bBx2ni K 4 F2v#Q `/(/ @ ^y^)XbBx2UVc
`2bmHiX`2bBx2UM
KVc
7Q` UbBx2ni B 4 yc B I Kc YYBV
+QTvU`2bmHiX#2;BMUV- `2bmHiX#2;BMUV Y M- `2bmHiX#2;BMUV Y M
7Q` UbBx2ni B 4 yc B I Kc YYBV &
miQ #2;BM 4 `2bmHiX#2;BMUVc
7Q`n2 +?U#2;BM Y M
B- #2;BM Y M
b Y4 F2v#Q `/(/ @ ^y^)(B)c
'Vc
'
'c
'
'
`2im`M `2bmHic
UBYRV- ( )Ubi`BM; bV &
BVc
A*
9.1 Word Ladder
Given two words (start and end), and a dictionary, find the length of shortest transformation sequence
from start to end, such that:
Only one letter can be changed at a time
Each intermediate word must exist in the dictionary
For example, Given:
bi `i 4 ]?Bi]
2M/ 4 ]+Q;]
/B+i 4 (]?Qi]-]/Qi]-]/Q;]-]HQi]-]HQ;])
As one shortest transformation is ]?Bi] @= ]?Qi] @= ]/Qi] @= ]/Q;] @= ]+Q;], return its length 5.
Note:
Return 0 if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.
150
151
9.1 Word Ladder
ffG22i*Q/2- qQ`/ G //2`
ff
PUMV
bi`m+i bi i2ni &
bi`BM; rQ`/c
BMi H2p2Hc
PUMV
bi i2niUV & rQ`/ 4 ]]c H2p2H 4 yc '
bi i2niU+QMbi bi`BM; rQ`/- BMi H2p2HV &
i?Bb@=rQ`/ 4 rQ`/c
i?Bb@=H2p2H 4 H2p2Hc
'
'c
#QQH QT2` iQ`44U+QMbi bi i2ni Qi?2`V +QMbi &
`2im`M i?Bb@=rQ`/ 44 Qi?2`XrQ`/c
'
M K2bT +2 bi/ &
i2KTH i2I= bi`m+i ? b?Ibi i2ni= &
Tm#HB+,
bBx2ni QT2` iQ`UVU+QMbi bi i2ni bV +QMbi &
`2im`M bi`n? b?UbXrQ`/Vc
'
T`Bp i2,
bi/,,? b?Ibi/,,bi`BM;= bi`n? b?c
'c
'
+H bb aQHmiBQM &
Tm#HB+,
BMi H //2`G2M;i?U+QMbi bi`BM; bi `i- +QMbi bi`BM; 2M/+QMbi mMQ`/2`2/nb2iIbi`BM;= /B+iV &
[m2m2Ibi i2ni= [c
mMQ`/2`2/nb2iIbi i2ni= pBbBi2/c ff
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV &
`2im`M /B+iX7BM/UbXrQ`/V 54 /B+iX2M/UV %% bXrQ`/ 44 2M/c
'c
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni bV &`2im`M bXrQ`/ 44 2M/c 'c
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
mMQ`/2`2/nb2iIbi i2ni= `2bmHic
7Q` UbBx2ni B 4 yc B I bXrQ`/XbBx2UVc YYBV &
bi i2ni M2rnbi i2UbXrQ`/- bXH2p2H Y RVc
7Q` U+? ` + 4 ^ ^c + I4 ^x^c +YYV &
ff
B7 U+ 44 M2rnbi i2XrQ`/(B)V +QMiBMm2c
br TU+- M2rnbi i2XrQ`/(B)Vc
152
'
'c
'
B7 Ubi i2nBbnp HB/UM2rnbi i2V
pBbBi2/X7BM/UM2rnbi i2V 44 pBbBi2/X2M/UVV &
`2bmHiXBMb2`iUM2rnbi i2Vc
'
br TU+- M2rnbi i2XrQ`/(B)Vc ff
`2im`M `2bmHic
bi i2ni bi `inbi i2Ubi `i- yVc
[XTmb?Ubi `inbi i2Vc
pBbBi2/XBMb2`iUbi `inbi i2Vc
r?BH2 U5[X2KTivUVV &
ff
+QMbi miQ TQTUV
ff
+QMbi miQ bi i2 4 [X7`QMiUVc
[XTQTUVc
B7 Ubi i2nBbni `;2iUbi i2VV &
`2im`M bi i2XH2p2H Y Rc
'
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
[XTmb?UM2rnbi i2Vc
pBbBi2/XBMb2`iUM2rnbi i2Vc
'
'c
'
'
`2im`M yc
ffG22i*Q/2- qQ`/ G //2`
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi H //2`G2M;i?U+QMbi bi`BM; bi `i- +QMbi bi`BM; 2M/+QMbi mMQ`/2`2/nb2iIbi`BM;= /B+iV &
[m2m2Ibi`BM;= +m``2Mi- M2tic
ff
mMQ`/2`2/nb2iIbi`BM;= pBbBi2/c ff
BMi H2p2H 4 @Rc
ff
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi`BM; bV &
`2im`M /B+iX7BM/UbV 54 /B+iX2M/UV %% b 44 2M/c
'c
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi`BM; bV &`2im`M b 44 2M/c'c
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi`BM; bV &
mMQ`/2`2/nb2iIbi`BM;= `2bmHic
153
9.1 Word Ladder
7Q` UbBx2ni B 4 yc B I bXbBx2UVc YYBV &
bi`BM; M2rnrQ`/UbVc
7Q` U+? ` + 4 ^ ^c + I4 ^x^c +YYV &
ff
B7 U+ 44 M2rnrQ`/(B)V +QMiBMm2c
br TU+- M2rnrQ`/(B)Vc
'
'c
'
B7 Ubi i2nBbnp HB/UM2rnrQ`/V
pBbBi2/X7BM/UM2rnrQ`/V 44 pBbBi2/X2M/UVV &
`2bmHiXBMb2`iUM2rnrQ`/Vc
'
br TU+- M2rnrQ`/(B)Vc ff
`2im`M `2bmHic
+m``2MiXTmb?Ubi `iVc
pBbBi2/XBMb2`iUbi `iVc
r?BH2 U5+m``2MiX2KTivUVV &
YYH2p2Hc
r?BH2 U5+m``2MiX2KTivUVV &
ff
+QMbi miQ TQTUV
ff
+QMbi miQ bi i2 4 +m``2MiX7`QMiUVc
+m``2MiXTQTUVc
B7 Ubi i2nBbni `;2iUbi i2VV &
`2im`M H2p2H Y Rc
'
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
M2tiXTmb?UM2rnbi i2Vc
pBbBi2/XBMb2`iUM2rnbi i2Vc
'
'
br TUM2ti- +m``2MiVc
'c
'
'
`2im`M yc
Word Ladder II
9.2
154
9.2 Word Ladder II
Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start
to end, such that:
Only one letter can be changed at a time
Each intermediate word must exist in the dictionary
For example, Given:
bi `i 4 ]?Bi]
2M/ 4 ]+Q;]
/B+i 4 (]?Qi]-]/Qi]-]/Q;]-]HQi]-]HQ;])
Return
(
)
(]?Bi]-]?Qi]-]/Qi]-]/Q;]-]+Q;])(]?Bi]-]?Qi]-]HQi]-]HQ;]-]+Q;])
Note:
All words have the same length.
All words contain only lowercase alphabetic characters.
Word Ladder
BFS
ffG22i*Q/2- qQ`/ G //2` AA
ff
PUMV
bi`m+i bi i2ni &
bi`BM; rQ`/c
BMi H2p2Hc
PUMV
bi i2niUV & rQ`/ 4 ]]c H2p2H 4 yc '
bi i2niU+QMbi bi`BM; rQ`/- BMi H2p2HV &
i?Bb@=rQ`/ 4 rQ`/c
i?Bb@=H2p2H 4 H2p2Hc
'
155
9.2 Word Ladder II
'c
#QQH QT2` iQ`44U+QMbi bi i2ni Qi?2`V +QMbi &
`2im`M i?Bb@=rQ`/ 44 Qi?2`XrQ`/c
'
M K2bT +2 bi/ &
i2KTH i2I= bi`m+i ? b?Ibi i2ni= &
Tm#HB+,
bBx2ni QT2` iQ`UVU+QMbi bi i2ni bV +QMbi &
`2im`M bi`n? b?UbXrQ`/Vc
'
T`Bp i2,
bi/,,? b?Ibi/,,bi`BM;= bi`n? b?c
'c
'
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;= = 7BM/G //2`bU+QMbi bi`BM; bi `i+QMbi bi`BM; 2M/- +QMbi mMQ`/2`2/nb2iIbi`BM;= /B+iV &
[m2m2Ibi i2ni= [c
mMQ`/2`2/nb2iIbi i2ni= pBbBi2/c ff
mMQ`/2`2/nK TIbi i2ni- p2+iQ`Ibi i2ni= = 7 i?2`c ff .:
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV &
`2im`M /B+iX7BM/UbXrQ`/V 54 /B+iX2M/UV %% bXrQ`/ 44 2M/c
'c
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni bV &`2im`M bXrQ`/ 44 2M/c 'c
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
mMQ`/2`2/nb2iIbi i2ni= `2bmHic
7Q` UbBx2ni B 4 yc B I bXrQ`/XbBx2UVc YYBV &
bi i2ni M2rnbi i2UbXrQ`/- bXH2p2H Y RVc
7Q` U+? ` + 4 ^ ^c + I4 ^x^c +YYV &
ff
B7 U+ 44 M2rnbi i2XrQ`/(B)V +QMiBMm2c
br TU+- M2rnbi i2XrQ`/(B)Vc
B7 Ubi i2nBbnp HB/UM2rnbi i2VV &
miQ pBbBi2/nBi2` 4 pBbBi2/X7BM/UM2rnbi i2Vc
B7 UpBbBi2/nBi2` 54 pBbBi2/X2M/UVV &
B7 UpBbBi2/nBi2`@=H2p2H I M2rnbi i2XH2p2HV &
ff /Q MQi?BM;
' 2Hb2 B7 UpBbBi2/nBi2`@=H2p2H 44 M2rnbi i2XH2p2HV &
`2bmHiXBMb2`iUM2rnbi i2Vc
' 2Hb2 & ff MQi TQbbB#H2
i?`Qr bi/,,HQ;B+n2``Q`U]MQi TQbbB#H2 iQ ;2i ?2`2]Vc
'
' 2Hb2 &
`2bmHiXBMb2`iUM2rnbi i2Vc
156
'
'c
'
'
'
br TU+- M2rnbi i2XrQ`/(B)Vc ff
`2im`M `2bmHic
p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHic
bi i2ni bi `inbi i2Ubi `i- yVc
[XTmb?Ubi `inbi i2Vc
pBbBi2/XBMb2`iUbi `inbi i2Vc
r?BH2 U5[X2KTivUVV &
ff
+QMbi miQ TQTUV
ff
+QMbi miQ bi i2 4 [X7`QMiUVc
[XTQTUVc
ff
ff
B7 U5`2bmHiX2KTivUV bi i2XH2p2H Y R = `2bmHi(y)XbBx2UVV #`2 Fc
B7 Ubi i2nBbni `;2iUbi i2VV &
p2+iQ`Ibi`BM;= T i?c
;2MnT i?U7 i?2`- bi `inbi i2- bi i2- T i?- `2bmHiVc
+QMiBMm2c
'
ff
"
ff
[
ff pBbBi2/XBMb2`iUbi i2Vc
'
ff
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
B7 UpBbBi2/X7BM/UM2rnbi i2V 44 pBbBi2/X2M/UVV &
[XTmb?UM2rnbi i2Vc
'
pBbBi2/XBMb2`iUM2rnbi i2Vc
7 i?2`(M2rnbi i2)XTmb?n# +FUbi i2Vc
'
`2im`M `2bmHic
'
T`Bp i2,
pQB/ ;2MnT i?UmMQ`/2`2/nK TIbi i2ni- p2+iQ`Ibi i2ni= = 7 i?2`+QMbi bi i2ni bi `i- +QMbi bi i2ni bi i2- p2+iQ`Ibi`BM;= T i?p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHiV &
T i?XTmb?n# +FUbi i2XrQ`/Vc
B7 Ubi i2 44 bi `iV &
B7 U5`2bmHiX2KTivUVV &
B7 UT i?XbBx2UV I `2bmHi(y)XbBx2UVV &
157
9.2 Word Ladder II
`2bmHiX+H2 `UVc
`2bmHiXTmb?n# +FUT i?Vc
`2p2`b2U`2bmHiX# +FUVX#2;BMUV- `2bmHiX# +FUVX2M/UVVc
' 2Hb2 B7 UT i?XbBx2UV 44 `2bmHi(y)XbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
`2p2`b2U`2bmHiX# +FUVX#2;BMUV- `2bmHiX# +FUVX2M/UVVc
' 2Hb2 & ff MQi TQbbB#H2
i?`Qr bi/,,HQ;B+n2``Q`U]MQi TQbbB#H2 iQ ;2i ?2`2 ]Vc
'
' 2Hb2 &
`2bmHiXTmb?n# +FUT i?Vc
`2p2`b2U`2bmHiX# +FUVX#2;BMUV- `2bmHiX# +FUVX2M/UVVc
'
'c
'
' 2Hb2 &
7Q` U+QMbi miQ 7 , 7 i?2`(bi i2)V &
;2MnT i?U7 i?2`- bi `i- 7- T i?- `2bmHiVc
'
'
T i?XTQTn# +FUVc
ffG22i*Q/2- qQ`/ G //2` AA
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;= = 7BM/G //2`bU+QMbi bi`BM; bi `i+QMbi bi`BM; 2M/- +QMbi mMQ`/2`2/nb2iIbi`BM;= /B+iV &
ff
mMQ`/2`2/nb2i
ff
p2+iQ`M2ti
ff
7 i?2`
M2ti
mMQ`/2`2/nb2iIbi`BM;= +m``2Mi- M2tic
mMQ`/2`2/nb2iIbi`BM;= pBbBi2/c ff
mMQ`/2`2/nK TIbi`BM;- p2+iQ`Ibi`BM;= = 7 i?2`c ff .:
BMi H2p2H 4 @Rc
ff
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi`BM; bV &
`2im`M /B+iX7BM/UbV 54 /B+iX2M/UV %% b 44 2M/c
'c
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi`BM; bV &`2im`M b 44 2M/c'c
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi`BM; bV &
mMQ`/2`2/nb2iIbi`BM;= `2bmHic
7Q` UbBx2ni B 4 yc B I bXbBx2UVc YYBV &
bi`BM; M2rnrQ`/UbVc
7Q` U+? ` + 4 ^ ^c + I4 ^x^c +YYV &
ff
B7 U+ 44 M2rnrQ`/(B)V +QMiBMm2c
158
9
br TU+- M2rnrQ`/(B)Vc
'
'c
'
B7 Ubi i2nBbnp HB/UM2rnrQ`/V
pBbBi2/X7BM/UM2rnrQ`/V 44 pBbBi2/X2M/UVV &
`2bmHiXBMb2`iUM2rnrQ`/Vc
'
br TU+- M2rnrQ`/(B)Vc ff
`2im`M `2bmHic
p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHic
+m``2MiXBMb2`iUbi `iVc
r?BH2 U5+m``2MiX2KTivUVV &
YY H2p2Hc
ff
ff
B7 U5`2bmHiX2KTivUV H2p2HYR = `2bmHi(y)XbBx2UVV #`2 Fc
ff RX
pBbBi2/ff kX
+m``2Mi
pBbBi2/ff
7Q` U+QMbi miQ bi i2 , +m``2MiV
pBbBi2/XBMb2`iUbi i2Vc
7Q` U+QMbi miQ bi i2 , +m``2MiV &
B7 Ubi i2nBbni `;2iUbi i2VV &
p2+iQ`Ibi`BM;= T i?c
;2MnT i?U7 i?2`- T i?- bi `i- bi i2- `2bmHiVc
+QMiBMm2c
'
'
'
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
M2tiXBMb2`iUM2rnbi i2Vc
7 i?2`(M2rnbi i2)XTmb?n# +FUbi i2Vc
'
+m``2MiX+H2 `UVc
br TU+m``2Mi- M2tiVc
`2im`M `2bmHic
'
T`Bp i2,
pQB/ ;2MnT i?UmMQ`/2`2/nK TIbi`BM;- p2+iQ`Ibi`BM;= = 7 i?2`p2+iQ`Ibi`BM;= T i?- +QMbi bi`BM; bi `i- +QMbi bi`BM; rQ`/p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHiV &
T i?XTmb?n# +FUrQ`/Vc
B7 UrQ`/ 44 bi `iV &
B7 U5`2bmHiX2KTivUVV &
159
9.2 Word Ladder II
'c
'
B7 UT i?XbBx2UV I `2bmHi(y)XbBx2UVV &
`2bmHiX+H2 `UVc
`2bmHiXTmb?n# +FUT i?Vc
' 2Hb2 B7UT i?XbBx2UV 44 `2bmHi(y)XbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
' 2Hb2 &
ff MQi TQbbB#H2
i?`Qr bi/,,HQ;B+n2``Q`U]MQi TQbbB#H2 iQ ;2i ?2`2]Vc
'
' 2Hb2 &
`2bmHiXTmb?n# +FUT i?Vc
'
`2p2`b2U`2bmHiX# +FUVX#2;BMUV- `2bmHiX# +FUVX2M/UVVc
' 2Hb2 &
7Q` U+QMbi miQ 7 , 7 i?2`(rQ`/)V &
;2MnT i?U7 i?2`- T i?- bi `i- 7- `2bmHiVc
'
'
T i?XTQTn# +FUVc
/B+i
ffG22i*Q/2- qQ`/ G //2` AA
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;= = 7BM/G //2`bU+QMbi bi`BM; bi `i+QMbi bi`BM; 2M/- +QMbi mMQ`/2`2/nb2iIbi`BM;= /B+iV &
+QMbi miQ ; 4 #mBH/n;` T?U/B+iVc
p2+iQ`Ibi i2ni = TQQHc
[m2m2Ibi i2ni = [c ff
ff p Hm2
mMQ`/2`2/nK TIbi`BM;- BMi= pBbBi2/c
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni
bV &`2im`M b@=rQ`/ 44 2M/c 'c
p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHic
[XTmb?U+`2 i2nbi i2UMmHHTi`- bi `i- y- TQQHVVc
r?BH2 U5[X2KTivUVV &
bi i2ni bi i2 4 [X7`QMiUVc
[XTQTUVc
ff
ff
B7 U5`2bmHiX2KTivUV bi i2@=H2p2HYR = `2bmHi(y)XbBx2UVV #`2 Fc
B7 Ubi i2nBbni `;2iUbi i2VV &
160
9
+QMbi miQ T i? 4 ;2MnT i?Ubi i2Vc
B7 U`2bmHiX2KTivUVV &
`2bmHiXTmb?n# +FUT i?Vc
' 2Hb2 &
B7 UT i?XbBx2UV I `2bmHi(y)XbBx2UVV &
`2bmHiX+H2 `UVc
`2bmHiXTmb?n# +FUT i?Vc
' 2Hb2 B7 UT i?XbBx2UV 44 `2bmHi(y)XbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
' 2Hb2 &
ff MQi TQbbB#H2
i?`Qr bi/,,HQ;B+n2``Q`U]MQi TQbbB#H2 iQ ;2i ?2`2]Vc
'
'
+QMiBMm2c
'
pBbBi2/(bi i2@=rQ`/) 4 bi i2@=H2p2Hc
ff
miQ Bi2` 4 ;X7BM/Ubi i2@=rQ`/Vc
B7 UBi2` 44 ;X2M/UVV +QMiBMm2c
7Q` U+QMbi miQ M2B;?#Q` , Bi2`@=b2+QM/V &
miQ pBbBi2/nBi2` 4 pBbBi2/X7BM/UM2B;?#Q`Vc
B7 UpBbBi2/nBi2` 54 pBbBi2/X2M/UV
pBbBi2/nBi2`@=b2+QM/ I bi i2@=H2p2H Y RV &
+QMiBMm2c
'
'
'
'
[XTmb?U+`2 i2nbi i2Ubi i2- M2B;?#Q`- bi i2@=H2p2H Y R- TQQHVVc
ff `2H2 b2 HH bi i2b
7Q` U miQ bi i2 , TQQHV &
/2H2i2 bi i2c
'
`2im`M `2bmHic
T`Bp i2,
bi`m+i bi i2ni &
bi i2ni 7 i?2`c
bi`BM; rQ`/c
BMi H2p2Hc ff
'c
bi i2niUbi i2ni 7 i?2`n- +QMbi bi`BM; rQ`/n- BMi H2p2HnV ,
7 i?2`U7 i?2`nV- rQ`/UrQ`/nV- H2p2HUH2p2HnV &'
bi i2ni
+`2 i2nbi i2Ubi i2ni T `2Mi- +QMbi bi`BM; p Hm2BMi H2M;i?- p2+iQ`Ibi i2ni = TQQHV &
161
9.2 Word Ladder II
bi i2ni MQ/2 4 M2r bi i2niUT `2Mi- p Hm2- H2M;i?Vc
TQQHXTmb?n# +FUMQ/2Vc
`2im`M MQ/2c
'
p2+iQ`Ibi`BM;= ;2MnT i?U+QMbi bi i2ni
p2+iQ`Ibi`BM;= T i?c
MQ/2V &
r?BH2UMQ/2 54 MmHHTi`V &
T i?XTmb?n# +FUMQ/2@=rQ`/Vc
MQ/2 4 MQ/2@=7 i?2`c
'
'
`2p2`b2UT i?X#2;BMUV- T i?X2M/UVVc
`2im`M T i?c
mMQ`/2`2/nK TIbi`BM;- mMQ`/2`2/nb2iIbi`BM;= = #mBH/n;` T?U
+QMbi mMQ`/2`2/nb2iIbi`BM;= /B+iV &
mMQ`/2`2/nK TIbi`BM;- mMQ`/2`2/nb2iIbi`BM;= = /D +2M+vnHBbic
7Q` U+QMbi miQ rQ`/ , /B+iV &
7Q` UbBx2ni B 4 yc B I rQ`/XbBx2UVc YYBV &
bi`BM; M2rnrQ`/UrQ`/Vc
7Q` U+? ` + 4 ^ ^c + I4 ^x^c +YYV &
ff
B7 U+ 44 M2rnrQ`/(B)V +QMiBMm2c
br TU+- M2rnrQ`/(B)Vc
'
'c
'
'
B7 UU/B+iX7BM/UM2rnrQ`/V 54 /B+iX2M/UVVV &
miQ Bi2` 4 /D +2M+vnHBbiX7BM/UrQ`/Vc
B7 UBi2` 54 /D +2M+vnHBbiX2M/UVV &
Bi2`@=b2+QM/XBMb2`iUM2rnrQ`/Vc
' 2Hb2 &
/D +2M+vnHBbiXBMb2`iUT B`Ibi`BM;mMQ`/2`2/nb2iIbi`BM;==UrQ`/- mMQ`/2`2/nb2iIbi`BM;=UVVVc
/D +2M+vnHBbi(rQ`/)XBMb2`iUM2rnrQ`/Vc
'
'
br TU+- M2rnrQ`/(B)Vc ff
'
`2im`M /D +2M+vnHBbic
Word Ladder
9.1
162
9.3 Surrounded Regions
Given a 2D board containing ^s^ and ^P^, capture all regions surrounded by ^s^.
A region is captured by flipping all ^P^s into ^s^s in that surrounded region .
For example,
s
s
s
s
s
P
s
P
s
P
P
s
s
s
s
s
After running your function, the board should be:
s
s
s
s
s
s
s
P
s
s
s
s
s
s
s
s
^P^
ff G22i*Q/2- am``QmM/2/ _2;BQMb
ff "6a
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
pQB/ bQHp2Up2+iQ`Ip2+iQ`I+? `== #Q `/V &
B7 U#Q `/X2KTivUVV `2im`Mc
+QMbi BMi K 4 #Q `/XbBx2UVc
+QMbi BMi M 4 #Q `/(y)XbBx2UVc
7Q` UBMi B 4 yc B I Mc BYYV &
#7bU#Q `/- y- BVc
#7bU#Q `/- K @ R- BVc
'
7Q` UBMi D 4 Rc D I K @ Rc DYYV &
#7bU#Q `/- D- yVc
#7bU#Q `/- D- M @ RVc
'
7Q` UBMi B 4 yc B I Kc BYYV
7Q` UBMi D 4 yc D I Mc DYYV
B7 U#Q `/(B)(D) 44 ^P^V
#Q `/(B)(D) 4 ^s^c
2Hb2 B7 U#Q `/(B)(D) 44 ^Y^V
#Q `/(B)(D) 4 ^P^c
'
T`Bp i2,
pQB/ #7bUp2+iQ`Ip2+iQ`I+? `== #Q `/- BMi B- BMi DV &
9.3 Surrounded Regions
ivT2/27 T B`IBMi- BMi= bi i2nic
[m2m2Ibi i2ni= [c
+QMbi BMi K 4 #Q `/XbBx2UVc
+QMbi BMi M 4 #Q `/(y)XbBx2UVc
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV &
+QMbi BMi t 4 bX7B`bic
+QMbi BMi v 4 bXb2+QM/c
B7 Ut I y %% t =4 K %% v I y %% v =4 M %% #Q `/(t)(v) 54 ^P^V
`2im`M 7 Hb2c
`2im`M i`m2c
'c
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
p2+iQ`Ibi i2ni= `2bmHic
+QMbi BMi t 4 bX7B`bic
+QMbi BMi v 4 bXb2+QM/c
ff
+QMbi bi i2ni M2rnbi i2b(9) 4 &&t@R-v'- &tYR-v'&t-v@R'- &t-vYR''c
7Q` UBMi F 4 yc F I 9c YYFV &
B7 Ubi i2nBbnp HB/UM2rnbi i2b(F)VV &
ff
#Q `/(M2rnbi i2b(F)X7B`bi)(M2rnbi i2b(F)Xb2+QM/) 4 ^Y^c
`2bmHiXTmb?n# +FUM2rnbi i2b(F)Vc
'
'
'c
'c
'
`2im`M `2bmHic
bi i2ni bi `i 4 & B- D 'c
B7 Ubi i2nBbnp HB/Ubi `iVV &
#Q `/(B)(D) 4 ^Y^c
[XTmb?Ubi `iVc
'
r?BH2 U5[X2KTivUVV &
miQ +m` 4 [X7`QMiUVc
[XTQTUVc
miQ M2rnbi i2b 4 bi i2n2ti2M/U+m`Vc
7Q` U miQ b , M2rnbi i2bV [XTmb?UbVc
'
163
164
9.4
9.4.1
DAG
9.4.2
1.
(a)
(b)
i.
ii.
4
2.
3.
4.
BFS
(a)
(b)
DAG
pBbBi2/
pBbBi2/
(c)
i.
mMQ`/2`2/n@
ii.
b2i
head
next
??
165
9.4
iii.
5.
9.4.3
hashset
[m2m2
p2+iQ`
bi i2ni
1.
H2p2H
H2p2H
[m2m2
A*
T`BQ`Bivn[m2m2
+m``2Mi- M2ti
2.
H2p2H
H2p2H
H2p2H
(#QQH pBbBi2/(ahh1nJs)
hashset
pBbBi2/Uahh1nJs- 7 Hb2V)
STL
STL
b2i
p2+iQ`I#QQH=
mMQ`/2`2/nb2i
mMQ`/2`2/nK TIbi i2ni- bi i2ni = 7 i?2`
(bi i2ni MQ/2b(ahh1n@
STATE_MAX
Js))
f
f
bi`m+i bi i2ni &
BMi / i Rc f
BMi / i kc f
ff / i Lc
f
BMi +iBQMc f
BMi H2p2Hc f
'c
ff
bfs_common.h
X
X
f
f
#QQH QT2` iQ`44U+QMbi bi i2ni Qi?2`V +QMbi &
`2im`M i`m2c ff
'
? b?
ff
R
? b?
M K2bT +2 bi/ &
i2KTH i2I= bi`m+i ? b?Ibi i2ni= &
@R
f
f
166
'c
'
9
bBx2ni QT2` iQ`UVU+QMbi bi i2ni tV +QMbi &
`2im`M yc ff
'
ff
k
? b?
+H bb > b?2` &
Tm#HB+,
> b?2`UBMi nKV , KUnKV &'c
bBx2ni QT2` iQ`UVU+QMbi bi i2ni bV +QMbi &
`2im`M yc ff
'
T`Bp i2,
BMi Kc ff
'c
f
!#`B27
X
!T ` K(BM) 7 i?2`
!T ` K(BM) i `;2i
!`2im`M
i `;2i
f
p2+iQ`Ibi i2ni= ;2MnT i?U+QMbi mMQ`/2`2/nK TIbi i2ni- bi i2ni= 7 i?2`+QMbi bi i2ni i `;2iV &
p2+iQ`Ibi i2ni= T i?c
T i?XTmb?n# +FUi `;2iVc
7Q` Ubi i2ni +m` 4 i `;2ic 7 i?2`X7BM/U+m`V 54 7 i?2`X2M/UVc
+m` 4 7 i?2`X iU+m`VV
T i?XTmb?n# +FU+m`Vc
`2p2`b2UT i?X#2;BMUV- T i?X2M/UVVc
'
f
`2im`M T i?c
X
!T ` K(BM) 7 i?2`
!T ` K(BM) bi `i
!T ` K(BM) bi i2
!`2im`M
f
pQB/ ;2MnT i?UmMQ`/2`2/nK TIbi i2ni- p2+iQ`Ibi i2ni= = 7 i?2`+QMbi bi`BM; bi `i- +QMbi bi i2ni bi i2- p2+iQ`Ibi i2ni= T i?p2+iQ`Ip2+iQ`Ibi i2ni= = `2bmHiV &
T i?XTmb?n# +FUbi i2Vc
B7 Ubi i2 44 bi `iV &
B7 U5`2bmHiX2KTivUVV &
B7 UT i?XbBx2UV I `2bmHi(y)XbBx2UVV &
`2bmHiX+H2 `UVc
`2bmHiXTmb?n# +FUT i?Vc
167
9.4
'
' 2Hb2 B7UT i?XbBx2UV 44 `2bmHi(y)XbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
' 2Hb2 &
ff MQi TQbbB#H2
i?`Qr bi/,,HQ;B+n2``Q`U]MQi TQbbB#H2 iQ ;2i ?2`2]Vc
'
' 2Hb2 &
`2bmHiXTmb?n# +FUT i?Vc
'
`2p2`b2U`2bmHiX# +FUVX#2;BMUV- `2bmHiX# +FUVX2M/UVVc
' 2Hb2 &
7Q` U+QMbi miQ 7 , 7 i?2`(bi i2)V &
;2MnT i?U7 i?2`- bi `i- 7- T i?- `2bmHiVc
'
'
T i?XTQTn# +FUVc
bfs_common.h
OBM+Hm/2 ]#7bn+QKKQMX?]
f
bfs_template.cpp
!#`B27
X
!T ` K(BM) bi `i
!T ` K(BM) / i
!`2im`M
f
p2+iQ`Ibi i2ni= #7bUbi i2ni bi `i- +QMbi p2+iQ`Ip2+iQ`IBMi== ;`B/V &
[m2m2Ibi i2ni= [c ff
mMQ`/2`2/nb2iIbi i2ni= pBbBi2/c ff
mMQ`/2`2/nK TIbi i2ni- bi i2ni= 7 i?2`c ff
ff
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
ff
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
ff
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
mMQ`/2`2/nb2iIbi i2ni= `2bmHic
7Q` Uf XXX fV &
+QMbi bi i2ni M2rnbi i2 4 f XXX fc
B7 Ubi i2nBbnp HB/UM2rnbi i2V
pBbBi2/X7BM/UM2rnbi i2V 54 pBbBi2/X2M/UVV &
`2bmHiXBMb2`iUM2rnbi i2Vc
'
'
168
'c
`2im`M `2bmHic
bb2`i Ubi `iXH2p2H 44 yVc
[XTmb?Ubi `iVc
r?BH2 U5[X2KTivUVV &
ff
+QMbi miQ TQTUV
ff
+QMbi bi i2ni bi i2 4 [X7`QMiUVc
[XTQTUVc
pBbBi2/XBMb2`iUbi i2Vc
ff
B7 Ubi i2nBbni `;2iUbi i2VV &
`2im`M `2im`M ;2MnT i?U7 i?2`- i `;2iVc ff
ff `2im`M bi i2XH2p2H Y Rc ff
'
'
'
ff
p2+iQ`Ibi i2ni= M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
[XTmb?UM2rnbi i2Vc
7 i?2`(M2rnbi i2) 4 bi i2c ff
ff pBbBi2/XBMb2`iUbi i2Vc ff
ff
[
ff
pBbBi2/
ff
- pBbBi2/XBMb2`iUbi `iV
'
pBbBi2/
r?BH2
`2im`M p2+iQ`Ibi i2ni=UVc
ff`2im`M yc
bfs_template.cpp
OBM+Hm/2 ]#7bn+QKKQMX?]
f
!#`B27
X
!T ` K(BM) bi `i
!T ` K(BM) / i
!`2im`M
f
p2+iQ`Ibi i2ni= #7bU+QMbi bi i2ni bi `i- +QMbi ivT2 / i V &
[m2m2Ibi i2ni= M2ti- +m``2Mic ff
mMQ`/2`2/nb2iIbi i2ni= pBbBi2/c ff
mMQ`/2`2/nK TIbi i2ni- bi i2ni= 7 i?2`c ff
BMi H2p2H 4 @Rc
ff
ff
bfs_template1.cpp
169
9.4
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
ff
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
ff
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
mMQ`/2`2/nb2iIbi i2ni= `2bmHic
7Q` Uf XXX fV &
+QMbi bi i2ni M2rnbi i2 4 f XXX fc
B7 Ubi i2nBbnp HB/UM2rnbi i2V
pBbBi2/X7BM/UM2rnbi i2V 54 pBbBi2/X2M/UVV &
`2bmHiXBMb2`iUM2rnbi i2Vc
'
'
`2im`M `2bmHic
'c
+m``2MiXTmb?Ubi `iVc
r?BH2 U5+m``2MiX2KTivUVV &
YYH2p2Hc
r?BH2 U5+m``2MiX2KTivUVV &
ff
+QMbi miQ TQTUV
ff
+QMbi miQ bi i2 4 +m``2MiX7`QMiUVc
+m``2MiXTQTUVc
pBbBi2/XBMb2`iUbi i2Vc
B7 Ubi i2nBbni `;2iUbi i2VV &
`2im`M `2im`M ;2MnT i?U7 i?2`- bi i2Vc ff
ff `2im`M bi i2XH2p2H Y Rc ff
'
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
M2tiXTmb?UM2rnbi i2Vc
7 i?2`(M2rnbi i2) 4 bi i2c
ff pBbBi2/XBMb2`iUbi i2Vc ff
pBbBi2/
ff
+m``2Mi
ff
pBbBi2/
ff
- pBbBi2/XBMb2`iUbi `iV
'
'
'
r?BH2
'
br TUM2ti- +m``2MiVc ff555
`2im`M p2+iQ`Ibi i2ni=UVc
ff `2im`M yc
bfs_template1.cpp
170
bfs_template.cpp
!#`B27
X
!T ` K(BM) bi `i
!T ` K(BM) / i
!`2im`M
f
p2+iQ`Ip2+iQ`Ibi i2ni= = #7bU+QMbi bi i2ni bi `i- +QMbi ivT2 / i V &
[m2m2Ibi i2ni= [c
mMQ`/2`2/nb2iIbi i2ni= pBbBi2/c ff
mMQ`/2`2/nK TIbi i2ni- p2+iQ`Ibi i2ni= = 7 i?2`c ff .:
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
mMQ`/2`2/nb2iIbi i2ni= `2bmHic
7Q` Uf XXX fV &
+QMbi bi i2ni M2rnbi i2 4 f XXX fc
B7 Ubi i2nBbnp HB/UM2rnbi i2VV &
miQ pBbBi2/nBi2` 4 pBbBi2/X7BM/UM2rnbi i2Vc
'
'c
'
B7 UpBbBi2/nBi2` 54 pBbBi2/X2M/UVV &
B7 UpBbBi2/nBi2`@=H2p2H I M2rnbi i2XH2p2HV &
ff /Q MQi?BM;
' 2Hb2 B7 UpBbBi2/nBi2`@=H2p2H 44 M2rnbi i2XH2p2HV &
`2bmHiXBMb2`iUM2rnbi i2Vc
' 2Hb2 & ff MQi TQbbB#H2
i?`Qr bi/,,HQ;B+n2``Q`U]MQi TQbbB#H2 iQ ;2i ?2`2]Vc
'
' 2Hb2 &
`2bmHiXBMb2`iUM2rnbi i2Vc
'
`2im`M `2bmHic
p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHic
bi i2ni bi `inbi i2Ubi `i- yVc
[XTmb?Ubi `inbi i2Vc
pBbBi2/XBMb2`iUbi `inbi i2Vc
r?BH2 U5[X2KTivUVV &
ff
+QMbi miQ TQTUV
ff
+QMbi miQ bi i2 4 [X7`QMiUVc
[XTQTUVc
ff
ff
171
9.4
B7 U5`2bmHiX2KTivUV bi i2XH2p2H Y R = `2bmHi(y)XbBx2UVV #`2 Fc
B7 Ubi i2nBbni `;2iUbi i2VV &
p2+iQ`Ibi`BM;= T i?c
;2MnT i?U7 i?2`- bi `inbi i2- bi i2- T i?- `2bmHiVc
+QMiBMm2c
'
ff
"
ff
[
ff pBbBi2/XBMb2`iUbi i2Vc
'
'
ff
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
B7 UpBbBi2/X7BM/UM2rnbi i2V 44 pBbBi2/X2M/UVV &
[XTmb?UM2rnbi i2Vc
'
pBbBi2/XBMb2`iUM2rnbi i2Vc
7 i?2`(M2rnbi i2)XTmb?n# +FUbi i2Vc
'
`2im`M `2bmHic
bfs_template.cpp
OBM+Hm/2 ]#7bn+QKKQMX?]
f
bfs_template.cpp
!#`B27
X
!T ` K(BM) bi `i
!T ` K(BM) / i
!`2im`M
f
p2+iQ`Ip2+iQ`Ibi i2ni= = #7bU+QMbi bi i2ni bi `i- +QMbi ivT2 / i V &
ff
mMQ`/2`2/nb2i
ff
p2+iQ`M2ti
ff
7 i?2`
M2ti
mMQ`/2`2/nb2iIbi`BM;= +m``2Mi- M2tic
mMQ`/2`2/nb2iIbi i2ni= pBbBi2/c ff
mMQ`/2`2/nK TIbi i2ni- p2+iQ`Ibi i2ni= = 7 i?2`c ff .:
BMi H2p2H 4 @Rc
ff
ff
miQ bi i2nBbnp HB/ 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
ff
miQ bi i2nBbni `;2i 4 ( )U+QMbi bi i2ni bV & f XXX f 'c
ff
172
9
miQ bi i2n2ti2M/ 4 ( )U+QMbi bi i2ni bV &
mMQ`/2`2/nb2iIbi i2ni= `2bmHic
7Q` Uf XXX fV &
+QMbi bi i2ni M2rnbi i2 4 f XXX fc
B7 Ubi i2nBbnp HB/UM2rnbi i2V
pBbBi2/X7BM/UM2rnbi i2V 54 pBbBi2/X2M/UVV &
`2bmHiXBMb2`iUM2rnbi i2Vc
'
'
`2im`M `2bmHic
'c
p2+iQ`Ip2+iQ`Ibi i2ni= = `2bmHic
+m``2MiXBMb2`iUbi `iVc
r?BH2 U5+m``2MiX2KTivUVV &
YY H2p2Hc
ff
ff
B7 U5`2bmHiX2KTivUV H2p2HYR = `2bmHi(y)XbBx2UVV #`2 Fc
ff RX
pBbBi2/ff kX
+m``2Mi
pBbBi2/ff
7Q` U+QMbi miQ bi i2 , +m``2MiV
pBbBi2/XBMb2`iUbi i2Vc
7Q` U+QMbi miQ bi i2 , +m``2MiV &
B7 Ubi i2nBbni `;2iUbi i2VV &
p2+iQ`Ibi`BM;= T i?c
;2MnT i?U7 i?2`- T i?- bi `i- bi i2- `2bmHiVc
+QMiBMm2c
'
'
'
'
+QMbi miQ M2rnbi i2b 4 bi i2n2ti2M/Ubi i2Vc
7Q` U+QMbi miQ M2rnbi i2 , M2rnbi i2bV &
M2tiXBMb2`iUM2rnbi i2Vc
7 i?2`(M2rnbi i2)XTmb?n# +FUbi i2Vc
'
+m``2MiX+H2 `UVc
br TU+m``2Mi- M2tiVc
`2im`M `2bmHic
bfs_template.cpp
10
10.1 Palindrome Partitioning
Given a string s, partition s such that every substring of the partition is a palindrome.
Return all possible palindrome partitioning of s.
For example, given b 4 ] #], Return
(
)
(] ]-]#])(] ]-] ]-]#])
O(2n1 )
n1
1
ffG22i*Q/2- S HBM/`QK2 S `iBiBQMBM;
ff
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;== T `iBiBQMUbi`BM; bV &
p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHic
p2+iQ`Ibi`BM;= T i?c ff
T `iBiBQM
/7bUb- T i?- `2bmHi- y- RVc
`2im`M `2bmHic
'
ff T`2p
- bi `i
pQB/ /7bUbi`BM; b- p2+iQ`Ibi`BM;= T i?p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHi- bBx2ni T`2p- bBx2ni bi `iV &
B7 Ubi `i 44 bXbBx2UVV & ff
B7 UBbS HBM/`QK2Ub- T`2p- bi `i @ RVV & ff
T i?XTmb?n# +FUbXbm#bi`UT`2p- bi `i @ T`2pVVc
173
174
10
`2bmHiXTmb?n# +FUT i?Vc
T i?XTQTn# +FUVc
'
`2im`Mc
'
'c
'
ff
/7bUb- T i?- `2bmHi- T`2p- bi `i Y RVc
ff
(T`2p- bi `i@R)
B7 UBbS HBM/`QK2Ub- T`2p- bi `i @ RVV &
ff
T i?XTmb?n# +FUbXbm#bi`UT`2p- bi `i @ T`2pVVc
/7bUb- T i?- `2bmHi- bi `i- bi `i Y RVc
T i?XTQTn# +FUVc
'
#QQH BbS HBM/`QK2U+QMbi bi`BM; b- BMi bi `i- BMi 2M/V &
r?BH2 Ubi `i I 2M/ b(bi `i) 44 b(2M/)V &
YYbi `ic
@@2M/c
'
`2im`M bi `i =4 2M/c
'
2
Combination Sum, Combination Sum II
ffG22i*Q/2- S HBM/`QK2 S `iBiBQMBM;
ff
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;== T `iBiBQMUbi`BM; bV &
p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHic
p2+iQ`Ibi`BM;= T i?c ff
T `iBiBQM
.6aUb- T i?- `2bmHi- yVc
`2im`M `2bmHic
'
ff
b(bi `i)
T `iBiBQM
pQB/ .6aUbi`BM; b- p2+iQ`Ibi`BM;= T i?p2+iQ`Ip2+iQ`Ibi`BM;== `2bmHi- BMi bi `iV &
B7 Ubi `i 44 bXbBx2UVV &
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
7Q` UBMi B 4 bi `ic B I bXbBx2UVc BYYV &
B7 UBbS HBM/`QK2Ub- bi `i- BVV & ff
B
T i?XTmb?n# +FUbXbm#bi`Ubi `i- B @ bi `i Y RVVc
.6aUb- T i?- `2bmHi- B Y RVc ff
T i?XTQTn# +FUVc ff
'
'
175
10.1 Palindrome Partitioning
'c
'
#QQH BbS HBM/`QK2U+QMbi bi`BM; b- BMi bi `i- BMi 2M/V &
r?BH2 Ubi `i I 2M/ b(bi `i) 44 b(2M/)V &
YYbi `ic
@@2M/c
'
`2im`M bi `i =4 2M/c
'
ff G22i*Q/2- S HBM/`QK2 S `iBiBQMBM;
ff
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;= = T `iBiBQMUbi`BM; bV &
+QMbi BMi M 4 bXbBx2UVc
#QQH T(M)(M)c ff r?2i?2` b(B-D) Bb T HBM/`QK2
7BHHnMU T(y)(y)- M
M- 7 Hb2Vc
7Q` UBMi B 4 M @ Rc B =4 yc @@BV
7Q` UBMi D 4 Bc D I Mc YYDV
T(B)(D) 4 b(B) 44 b(D) UUD @ B I kV %% T(B Y R)(D @ R)Vc
'c
'
p2+iQ`Ip2+iQ`Ibi`BM;= = bm#nT HBMb(M)c ff bm# T HBM/`QK2b Q7 b(y-B)
7Q` UBMi B 4 M @ Rc B =4 yc @@BV &
7Q` UBMi D 4 Bc D I Mc YYDV
B7 UT(B)(D)V &
+QMbi bi`BM; T HBM/`QK2 4 bXbm#bi`UB- D @ B Y RVc
B7 UD Y R I MV &
7Q` U miQ p , bm#nT HBMb(D Y R)V &
pXBMb2`iUpX#2;BMUV- T HBM/`QK2Vc
bm#nT HBMb(B)XTmb?n# +FUpVc
'
' 2Hb2 &
bm#nT HBMb(B)XTmb?n# +FUp2+iQ`Ibi`BM;= & T HBM/`QK2 'Vc
'
'
'
`2im`M bm#nT HBMb(y)c
Palindrome Partitioning II
13.3
176
10
10.2 Unique Paths
A robot is located at the top-left corner of a m n grid (marked Start in the diagram below).
The robot can only move either down or right at any point in time. The robot is trying to reach the
bottom-right corner of the grid (marked Finish in the diagram below).
How many possible unique paths are there?
10-1 Above is a 3 7 grid. How many possible unique paths are there?
Note: m and n will be at most 100.
10.2.1
ff G22i*Q/2- lMB[m2 S i?b
ff
ff
PUM 9V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi mMB[m2S i?bUBMi K- BMi MV &
B7 UK I R %% M I RV `2im`M yc ff
B7 UK 44 R M 44 RV `2im`M Rc ff
'c
'
10.2.2
`2im`M mMB[m2S i?bUK @ R- MV Y mMB[m2S i?bUK- M @ RVc
177
10.2 Unique Paths
ff G22i*Q/2- lMB[m2 S i?b
ff
Y
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
BMi mMB[m2S i?bUBMi K- BMi MV &
ff 7(t)(v)
Uy-yV
Ut-vV
7 4 p2+iQ`Ip2+iQ`IBMi= =UK- p2+iQ`IBMi=UM- yVVc
7(y)(y) 4 Rc
`2im`M /7bUK @ R- M @ RVc
'
T`Bp i2,
p2+iQ`Ip2+iQ`IBMi= = 7c ff
BMi /7bUBMi t- BMi vV &
B7 Ut I y %% v I yV `2im`M yc ff
B7 Ut 44 y v 44 yV `2im`M 7(y)(y)c ff
'c
'
B7 U7(t)(v) = yV &
`2im`M 7(t)(v)c
' 2Hb2 &
`2im`M 7(t)(v) 4 /7bUt @ R- vV Y
'
/7bUt- v @ RVc
10.2.3
7(B)(D)
(1, 1)
(i, j)
7(B)(D)47(B@R)(D)Y7(B)(D@R)
ff G22i*Q/2- lMB[m2 S i?b
ff
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi mMB[m2S i?bUBMi K- BMi MV &
p2+iQ`IBMi= 7UM- yVc
7(y) 4 Rc
7Q` UBMi B 4 yc B I Kc BYYV &
7Q` UBMi D 4 Rc D I Mc DYYV &
ff
7(D)
7(D)
ff
7(D)
7(D)
7(D) 4 7(D) Y 7(D @ R)c
'
7(B)(D)
7(B@R)(D)
178
10
'c
'
'
`2im`M 7(M @ R)c
10.2.4
m
m1
m+n2
m1
Cm+n2
ff G22i*Q/2- lMB[m2 S i?b
ff
+H bb aQHmiBQM &
Tm#HB+,
ivT2/27 HQM; HQM; BMie9nic
ff
- M5fUbi `i@RV5
M UM@RVXXXbi `i
bi iB+ BMie9ni 7 +iQ`UBMi M- BMi bi `i 4 RV &
BMie9ni `2i 4 Rc
7Q`UBMi B 4 bi `ic B I4 Mc YYBV
`2i 4 Bc
`2im`M `2ic
'
ff
*nM F
bi iB+ BMie9ni +QK#BM iBQMUBMi M- BMi FV &
ff
B7 UF 44 yV `2im`M Rc
B7 UF 44 RV `2im`M Mc
'
'c
m1
m+n2
M =4 R
BMie9ni `2i 4 7 +iQ`UM- FYRVc
`2i f4 7 +iQ`UM @ FVc
`2im`M `2ic
BMi mMB[m2S i?bUBMi K- BMi MV &
ff K t
M
F
+QK#BM iBQMUV
`2im`M +QK#BM iBQMUKYM@k- K tUK@R- M@RVVc
'
Unique Paths II
Minimum Path Sum,
10.3
13.8
179
10.3 Unique Paths II
10.3 Unique Paths II
Follow up for Unique Paths:
Now consider if some obstacles are added to the grids. How many unique paths would there be?
An obstacle and empty space is marked as 1 and 0 respectively in the grid.
For example,
(
There is one obstacle in the middle of a 3 3 grid as illustrated below.
(y-y-y)(y-R-y)(y-y-y)
The total number of unique paths is 2.
Note: m and n will be at most 100.
10.3.1
ff G22i*Q/2- lMB[m2 S i?b AA
ff
Y
+H bb aQHmiBQM &
Tm#HB+,
BMi mMB[m2S i?bqBi?P#bi +H2bU+QMbi p2+iQ`Ip2+iQ`IBMi= = Q#bi +H2:`B/V &
+QMbi BMi K 4 Q#bi +H2:`B/XbBx2UVc
+QMbi BMi M 4 Q#bi +H2:`B/(y)XbBx2UVc
B7 UQ#bi +H2:`B/(y)(y) %% Q#bi +H2:`B/(K @ R)(M @ R)V `2im`M yc
7 4 p2+iQ`Ip2+iQ`IBMi= =UK- p2+iQ`IBMi=UM- yVVc
7(y)(y) 4 Q#bi +H2:`B/(y)(y) \ y , Rc
`2im`M /7bUQ#bi +H2:`B/- K @ R- M @ RVc
'
T`Bp i2,
p2+iQ`Ip2+iQ`IBMi= = 7c
ff
ff !`2im`M
Uy- yV
Ut- vV
BMi /7bU+QMbi p2+iQ`Ip2+iQ`IBMi= = Q#bi +H2:`B/BMi t- BMi vV &
B7 Ut I y %% v I yV `2im`M yc ff
ff Ut-vV
B7 UQ#bi +H2:`B/(t)(v)V `2im`M yc
B7 Ut 44 y M/ v 44 yV `2im`M 7(y)(y)c ff
180
10
'c
'
B7 U7(t)(v) = yV &
`2im`M 7(t)(v)c
' 2Hb2 &
`2im`M 7(t)(v) 4 /7bUQ#bi +H2:`B/- t @ R- vV Y
/7bUQ#bi +H2:`B/- t- v @ RVc
'
10.3.2
ff G22i*Q/2- lMB[m2 S i?b AA
ff
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi mMB[m2S i?bqBi?P#bi +H2bUp2+iQ`Ip2+iQ`IBMi= = Q#bi +H2:`B/V &
+QMbi BMi K 4 Q#bi +H2:`B/XbBx2UVc
+QMbi BMi M 4 Q#bi +H2:`B/(y)XbBx2UVc
B7 UQ#bi +H2:`B/(y)(y) %% Q#bi +H2:`B/(K@R)(M@R)V `2im`M yc
p2+iQ`IBMi= 7UM- yVc
7(y) 4 Q#bi +H2:`B/(y)(y) \ y , Rc
7Q` UBMi B 4 yc B I Kc BYYV &
7(y) 4 7(y) 44 y \ y , UQ#bi +H2:`B/(B)(y) \ y , RVc
7Q` UBMi D 4 Rc D I Mc DYYV
7(D) 4 Q#bi +H2:`B/(B)(D) \ y , U7(D) Y 7(D @ R)Vc
'
'c
'
`2im`M 7(M @ R)c
Unique Paths
10.2
Minimum Path Sum,
13.8
181
10.4 N-Queens
10.4 N-Queens
The n-queens puzzle is the problem of placing n queens on an n n chessboard such that no two queens
attack each other.
10-2 Eight Queens
Given an integer n, return all distinct solutions to the n-queens puzzle.
Each solution contains a distinct board configuration of the n-queens placement, where ^Z^ and ^X^
both indicate a queen and an empty space respectively.
For example, There exist two distinct solutions to the 4-queens puzzle:
(
(]XZXX]- ff aQHmiBQM R
]XXXZ]]ZXXX]]XXZX])(]XXZX]]ZXXX]]XXXZ]]XZXX])
ff aQHmiBQM k
182
10
p2+iQ`IBMi= *UM- yV, *(B)
1
ff G22i*Q/2- L@Zm22Mb
ff
Y
ff
PUM5 MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;= = bQHp2LZm22MbUBMi MV &
p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHic
p2+iQ`IBMi= *UM- @RVc ff *(B)
B
/7bU*- `2bmHi- yVc
`2im`M `2bmHic
'
T`Bp i2,
pQB/ /7bUp2+iQ`IBMi= *- p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHi- BMi `QrV &
+QMbi BMi L 4 *XbBx2UVc
B7 U`Qr 44 LV & ff
p2+iQ`Ibi`BM;= bQHmiBQMc
7Q` UBMi B 4 yc B I Lc YYBV &
bi`BM; bUL- ^X^Vc
7Q` UBMi D 4 yc D I Lc YYDV &
B7 UD 44 *(B)V b(D) 4 ^Z^c
'
bQHmiBQMXTmb?n# +FUbVc
'
`2bmHiXTmb?n# +FUbQHmiBQMVc
`2im`Mc
'
'
f
7Q` UBMi D 4 yc D I Lc YYDV & ff
+QMbi #QQH QF 4 Bbo HB/U*- `Qr- DVc
B7 U5QFV +QMiBMm2c ff
ff
*(`Qr) 4 Dc
/7bU*- `2bmHi- `Qr Y RVc
ff
ff *(`Qr) 4 @Rc
'
U`Qr- +QHV
!T ` K *
!T ` K `Qr
!T ` K +QH
!`2im`M
f
#QQH Bbo HB/U+QMbi p2+iQ`IBMi= *- BMi `Qr- BMi +QHV &
(i, C[i])
183
10.4 N-Queens
'c
'
7Q` UBMi B 4 yc B I `Qrc YYBV &
ff
B7 U*(B) 44 +QHV `2im`M 7 Hb2c
ff
B7 U #bUB @ `QrV 44 #bU*(B) @ +QHVV `2im`M 7 Hb2c
'
`2im`M i`m2c
2
ff G22i*Q/2- L@Zm22Mb
ff
Y
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`Ibi`BM;= = bQHp2LZm22MbUBMi MV &
i?Bb@=+QHmKMb 4 p2+iQ`I#QQH=UM- 7 Hb2Vc
i?Bb@=K BMn/B ; 4 p2+iQ`I#QQH=Uk
M @ R- 7 Hb2Vc
i?Bb@= MiBn/B ; 4 p2+iQ`I#QQH=Uk
M @ R- 7 Hb2Vc
p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHic
p2+iQ`IBMi= *UM- @RVc ff *(B)
/7bU*- `2bmHi- yVc
`2im`M `2bmHic
'
T`Bp i2,
ff
p2+iQ`I#QQH= +QHmKMbc ff
p2+iQ`I#QQH= K BMn/B ;c ff
p2+iQ`I#QQH= MiBn/B ;c ff
pQB/ /7bUp2+iQ`IBMi= *- p2+iQ`Ip2+iQ`Ibi`BM;= = `2bmHi- BMi `QrV &
+QMbi BMi L 4 *XbBx2UVc
B7 U`Qr 44 LV & ff
p2+iQ`Ibi`BM;= bQHmiBQMc
7Q` UBMi B 4 yc B I Lc YYBV &
bi`BM; bUL- ^X^Vc
7Q` UBMi D 4 yc D I Lc YYDV &
B7 UD 44 *(B)V b(D) 4 ^Z^c
'
bQHmiBQMXTmb?n# +FUbVc
'
`2bmHiXTmb?n# +FUbQHmiBQMVc
`2im`Mc
'
7Q` UBMi D 4 yc D I Lc YYDV & ff
+QMbi #QQH QF 4 5+QHmKMb(D) 5K BMn/B ;(`Qr @ D Y L @ R)
5 MiBn/B ;(`Qr Y D)c
B7 U5QFV +QMiBMm2c ff
ff
184
10
'c
'
*(`Qr) 4 Dc
+QHmKMb(D) 4 K BMn/B ;(`Qr @ D Y L @ R) 4 MiBn/B ;(`Qr Y D) 4 i`m2c
/7bU*- `2bmHi- `Qr Y RVc
ff
ff *(`Qr) 4 @Rc
+QHmKMb(D) 4 K BMn/B ;(`Qr @ D Y L @ R) 4 MiBn/B ;(`Qr Y D) 4 7 Hb2c
'
N-Queens II
10.5
10.5 N-Queens II
Follow up for N-Queens problem.
Now, instead outputting board configurations, return the total number of distinct solutions.
1
ff G22i*Q/2- L@Zm22Mb AA
ff
Y
ff
PUM5 MV
+H bb aQHmiBQM &
Tm#HB+,
BMi iQi HLZm22MbUBMi MV &
i?Bb@=+QmMi 4 yc
p2+iQ`IBMi= *UM- yVc
/7bU*- yVc
`2im`M i?Bb@=+QmMic
PUMV
ff *(B)
'
T`Bp i2,
BMi +QmMic ff
pQB/ /7bUp2+iQ`IBMi= *- BMi `QrV &
+QMbi BMi L 4 *XbBx2UVc
B7 U`Qr 44 LV & ff
YYi?Bb@=+QmMic
`2im`Mc
185
10.5 N-Queens II
'
'
f
'c
7Q` UBMi D 4 yc D I Lc YYDV & ff
+QMbi #QQH QF 4 Bbo HB/U*- `Qr- DVc
B7 U5QFV +QMiBMm2c ff
ff
*(`Qr) 4 Dc
/7bU*- `Qr Y RVc
ff
ff *(`Qr) 4 @Rc
'
U`Qr- +QHV
!T ` K *
!T ` K `Qr
!T ` K +QH
!`2im`M
f
#QQH Bbo HB/U+QMbi p2+iQ`IBMi= *- BMi `Qr- BMi +QHV &
7Q` UBMi B 4 yc B I `Qrc YYBV &
ff
B7 U*(B) 44 +QHV `2im`M 7 Hb2c
ff
B7 U #bUB @ `QrV 44 #bU*(B) @ +QHVV `2im`M 7 Hb2c
'
`2im`M i`m2c
'
2
ff G22i*Q/2- L@Zm22Mb AA
ff
Y
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi iQi HLZm22MbUBMi MV &
i?Bb@=+QmMi 4 yc
i?Bb@=+QHmKMb 4 p2+iQ`I#QQH=UM- 7 Hb2Vc
i?Bb@=K BMn/B ; 4 p2+iQ`I#QQH=Uk
M @ R- 7 Hb2Vc
i?Bb@= MiBn/B ; 4 p2+iQ`I#QQH=Uk
M @ R- 7 Hb2Vc
p2+iQ`IBMi= *UM- yVc
/7bU*- yVc
`2im`M i?Bb@=+QmMic
ff *(B)
'
T`Bp i2,
BMi +QmMic ff
ff
p2+iQ`I#QQH= +QHmKMbc ff
p2+iQ`I#QQH= K BMn/B ;c ff
186
10
p2+iQ`I#QQH= MiBn/B ;c
ff
pQB/ /7bUp2+iQ`IBMi= *- BMi `QrV &
+QMbi BMi L 4 *XbBx2UVc
B7 U`Qr 44 LV & ff
YYi?Bb@=+QmMic
`2im`Mc
'
'c
'
7Q` UBMi D 4 yc D I Lc YYDV & ff
+QMbi #QQH QF 4 5+QHmKMb(D)
5K BMn/B ;(`Qr @ D Y L)
5 MiBn/B ;(`Qr Y D)c
B7 U5QFV +QMiBMm2c ff
ff
*(`Qr) 4 Dc
+QHmKMb(D) 4 K BMn/B ;(`Qr @ D Y L) 4
MiBn/B ;(`Qr Y D) 4 i`m2c
/7bU*- `Qr Y RVc
ff
ff *(`Qr) 4 @Rc
+QHmKMb(D) 4 K BMn/B ;(`Qr @ D Y L) 4
MiBn/B ;(`Qr Y D) 4 7 Hb2c
'
N-Queens
10.4
10.6 Restore IP Addresses
Given a string containing only digits, restore it by returning all possible valid IP address combinations.
For example: Given ]k88k88RRRj8],
return (]k88Xk88XRRXRj8]- ]k88Xk88XRRRXj8]). (Order does not matter)
ff G22i*Q/2- _2biQ`2 AS //`2bb2b
ff
PUM 9V
PUMV
+H bb aQHmiBQM &
187
10.6 Restore IP Addresses
Tm#HB+,
p2+iQ`Ibi`BM;= `2biQ`2AT//`2bb2bU+QMbi bi`BM; bV &
p2+iQ`Ibi`BM;= `2bmHic
p2+iQ`Ibi`BM;= BTc ff
/7bUb- BT- `2bmHi- yVc
`2im`M `2bmHic
'
f
!#`B27
!T ` K(BM) b
!T ` K(Qmi) BT
!T ` K(Qmi) `2bmHi
AS
!T ` K(BM) bi `i
BM/2t
!`2im`M
f
pQB/ /7bUbi`BM; b- p2+iQ`Ibi`BM;= BT- p2+iQ`Ibi`BM;= `2bmHibBx2ni bi `iV &
B7 UBTXbBx2UV 44 9 bi `i 44 bXbBx2UVV & ff
`2bmHiXTmb?n# +FUBT(y) Y ^X^ Y BT(R) Y ^X^ Y BT(k) Y ^X^ Y BT(j)Vc
`2im`Mc
'
B7 UbXbBx2UV
`2im`Mc
B7 UbXbBx2UV
`2im`Mc
@ bi `i = U9 @ BTXbBx2UVV
ff
@ bi `i I U9 @ BTXbBx2UVVV
ff
jV
BMi MmK 4 yc
7Q` UbBx2ni B 4 bi `ic B I bi `i Y jc BYYV &
MmK 4 MmK
Ry Y Ub(B) @ ^y^Vc
B7 UMmK I y %% MmK = k88V +QMiBMm2c
ff
BTXTmb?n# +FUbXbm#bi`Ubi `i- B @ bi `i Y RVVc
/7bUb- BT- `2bmHi- B Y RVc
BTXTQTn# +FUVc
'c
'
'
B7 UMmK 44 yV #`2 Fc
ff
188
10
10.7 Combination Sum
Given a set of candidate numbers (C) and a target number (T ), find all unique combinations in C where
the candidate numbers sums to T .
The same repeated number may be chosen from C unlimited number of times.
Note:
All numbers (including target) will be positive integers.
Elements in a combination (a1 , a2 , ..., ak ) must be in non-descending order. (ie, a1 a2 ... ak ).
The solution set must not contain duplicate combinations.
For example, given candidate set k-j-e-d and target d, A solution set is:
(d)
(k- k- j)
ff G22i*Q/2- *QK#BM iBQM amK
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = +QK#BM iBQMamKUp2+iQ`IBMi= MmKb- BMi i `;2iV &
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc
p2+iQ`Ip2+iQ`IBMi= = `2bmHic ff
p2+iQ`IBMi= T i?c ff
/7bUMmKb- T i?- `2bmHi- i `;2i- yVc
`2im`M `2bmHic
'
T`Bp i2,
pQB/ /7bUp2+iQ`IBMi= MmKb- p2+iQ`IBMi= T i?- p2+iQ`Ip2+iQ`IBMi= = `2bmHiBMi ; T- BMi bi `iV &
B7 U; T 44 yV & ff
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
7Q` UbBx2ni B 4 bi `ic B I MmKbXbBx2UVc BYYV & ff
B7 U; T I MmKb(B)V `2im`Mc ff
'
T i?XTmb?n# +FUMmKb(B)Vc ff
/7bUMmKb- T i?- `2bmHi- ; T @ MmKb(B)- BVc
T i?XTQTn# +FUVc ff
189
10.8 Combination Sum II
'
'c
Combination Sum II
10.8
10.8 Combination Sum II
Given a collection of candidate numbers (C) and a target number (T ), find all unique combinations in
C where the candidate numbers sums to T .
Each number in C may only be used once in the combination.
Note:
All numbers (including target) will be positive integers.
Elements in a combination (a1 , a2 , ..., ak ) must be in non-descending order. (ie, a1 > a2 > ... > ak ).
The solution set must not contain duplicate combinations.
For example, given candidate set Ry-R-k-d-e-R-8 and target 3, A solution set is:
(R(R(k(R-
d)
k- 8)
e)
R- e)
ff G22i*Q/2- *QK#BM iBQM amK AA
ff
PUM5V
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = +QK#BM iBQMamKkUp2+iQ`IBMi= MmKb- BMi i `;2iV &
bQ`iUMmKbX#2;BMUV- MmKbX2M/UVVc ff
8y
ff
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`IBMi= T i?c
/7bUMmKb- T i?- `2bmHi- i `;2i- yVc
`2im`M `2bmHic
'
T`Bp i2,
ff
MmKb(bi `i- MmKbXbBx2UVV
190
10
bi iB+ pQB/ /7bU+QMbi p2+iQ`IBMi= MmKb- p2+iQ`IBMi= T i?p2+iQ`Ip2+iQ`IBMi= = `2bmHi- BMi ; T- BMi bi `iV &
B7 U; T 44 yV & ff
`2bmHiXTmb?n# +FUT i?Vc
`2im`Mc
'
BMi T`2pBQmb 4 @Rc
7Q` UbBx2ni B 4 bi `ic B I MmKbXbBx2UVc BYYV &
ff
MmKb(B)
ff
MmKb(B)
B7 UT`2pBQmb 44 MmKb(B)V +QMiBMm2c
B7 U; T I MmKb(B)V `2im`Mc
MmKb(B)
ff
T`2pBQmb 4 MmKb(B)c
'c
'
'
T i?XTmb?n# +FUMmKb(B)Vc
/7bUMmKb- T i?- `2bmHi- ; T @ MmKb(B)- B Y RVc
T i?XTQTn# +FUVc ff
Combination Sum
10.7
10.9 Generate Parentheses
Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
For example, given n = 3, a solution set is:
]UUUVVV]- ]UUVUVV]- ]UUVVUV]- ]UVUUVV]- ]UVUVUV]
<n
1
ff G22i*Q/2- :2M2` i2 S `2Mi?2b2b
ff
PUhP.PV
PUMV
+H bb aQHmiBQM &
191
10.9 Generate Parentheses
Tm#HB+,
p2+iQ`Ibi`BM;= ;2M2` i2S `2Mi?2bBbUBMi MV &
p2+iQ`Ibi`BM;= `2bmHic
bi`BM; T i?c
B7 UM = yV ;2M2` i2UM- T i?- `2bmHi- y- yVc
`2im`M `2bmHic
'
ff H
U
- `
V
pQB/ ;2M2` i2UBMi M- bi`BM; T i?- p2+iQ`Ibi`BM;= `2bmHi- BMi H- BMi `V &
B7 UH 44 MV &
bi`BM; bUT i?Vc
`2bmHiXTmb?n# +FUbX TT2M/UM @ `- ^V^VVc
`2im`Mc
'
T i?XTmb?n# +FU^U^Vc
;2M2` i2UM- T i?- `2bmHi- H Y R- `Vc
T i?XTQTn# +FUVc
'c
'
B7 UH = `V &
T i?XTmb?n# +FU^V^Vc
;2M2` i2UM- T i?- `2bmHi- H- ` Y RVc
T i?XTQTn# +FUVc
'
2
ff G22i*Q/2- :2M2` i2 S `2Mi?2b2b
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHB M+?2M;xDmV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ibi`BM;= ;2M2` i2S `2Mi?2bBb UBMi MV &
B7 UM 44 yV `2im`M p2+iQ`Ibi`BM;=UR- ]]Vc
B7 UM 44 RV `2im`M p2+iQ`Ibi`BM;= UR- ]UV]Vc
p2+iQ`Ibi`BM;= `2bmHic
7Q` UBMi B 4 yc B I Mc YYBV
7Q` U miQ BMM2` , ;2M2` i2S `2Mi?2bBb UBVV
7Q` U miQ Qmi2` , ;2M2` i2S `2Mi?2bBb UM @ R @ BVV
`2bmHiXTmb?n# +F U]U] Y BMM2` Y ]V] Y Qmi2`Vc
'c
'
`2im`M `2bmHic
Valid Parentheses,
4.1.1
192
10
Longest Valid Parentheses,
4.1.2
10.10 Sudoku Solver
Write a program to solve a Sudoku puzzle by filling the empty cells.
Empty cells are indicated by the character ^X^.
You may assume that there will be only one unique solution.
10-3 A sudoku puzzle...
10-4 ...and its solution numbers marked in red
193
10.11 Word Search
ff G22i*Q/2- am/QFm aQHp2`
ff
PUN 9V
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH bQHp2am/QFmUp2+iQ`Ip2+iQ`I+? `= = #Q `/V &
7Q` UBMi B 4 yc B I Nc YYBV
7Q` UBMi D 4 yc D I Nc YYDV &
B7 U#Q `/(B)(D) 44 ^X^V &
7Q` UBMi F 4 yc F I Nc YYFV &
#Q `/(B)(D) 4 ^R^ Y Fc
B7 UBbo HB/U#Q `/- B- DV bQHp2am/QFmU#Q `/VV
`2im`M i`m2c
#Q `/(B)(D) 4 ^X^c
'
`2im`M 7 Hb2c
'
'
`2im`M i`m2c
'
T`Bp i2,
ff
Ut- vV
#QQH Bbo HB/U+QMbi p2+iQ`Ip2+iQ`I+? `= = #Q `/- BMi t- BMi vV &
BMi B- Dc
7Q` UB 4 yc B I Nc BYYV ff
v
B7 UB 54 t #Q `/(B)(v) 44 #Q `/(t)(v)V
`2im`M 7 Hb2c
7Q` UD 4 yc D I Nc DYYV ff
t
B7 UD 54 v #Q `/(t)(D) 44 #Q `/(t)(v)V
`2im`M 7 Hb2c
7Q` UB 4 j
Ut f jVc B I j
Ut f j Y RVc BYYV
7Q` UD 4 j
Uv f jVc D I j
Uv f j Y RVc DYYV
B7 UUB 54 t %% D 54 vV #Q `/(B)(D) 44 #Q `/(t)(v)V
`2im`M 7 Hb2c
`2im`M i`m2c
'
'c
Valid Sudoku,
2.1.14
10.11 Word Search
Given a 2D board and a word, find if the word exists in the grid.
The word can be constructed from letters of sequentially adjacent cell, where ] /D +2Mi] cells are those
horizontally or vertically neighbouring. The same letter cell may not be used more than once.
194
10
For example, Given board =
(]"*1])(]a6*a])(].11])
word = ]"**1.], -> returns i`m2,
word = ]a11], -> returns i`m2,
word = ]"*"], -> returns 7 Hb2.
ff G22i*Q/2- qQ`/ a2 `+?
ff
ff
PUM k K kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
#QQH 2tBbiU+QMbi p2+iQ`Ip2+iQ`I+? `= = #Q `/- +QMbi bi`BM; rQ`/V &
+QMbi BMi K 4 #Q `/XbBx2UVc
+QMbi BMi M 4 #Q `/(y)XbBx2UVc
p2+iQ`Ip2+iQ`I#QQH= = pBbBi2/UK- p2+iQ`I#QQH=UM- 7 Hb2VVc
7Q` UBMi B 4 yc B I Kc YYBV
7Q` UBMi D 4 yc D I Mc YYDV
B7 U/7bU#Q `/- rQ`/- y- B- D- pBbBi2/VV
`2im`M i`m2c
`2im`M 7 Hb2c
'
T`Bp i2,
bi iB+ #QQH /7bU+QMbi p2+iQ`Ip2+iQ`I+? `= = #Q `/- +QMbi bi`BM; rQ`/BMi BM/2t- BMi t- BMi v- p2+iQ`Ip2+iQ`I#QQH= = pBbBi2/V &
B7 UBM/2t 44 rQ`/XbBx2UVV
`2im`M i`m2c ff
B7 Ut I y %% v I y %% t =4 #Q `/XbBx2UV %% v =4 #Q `/(y)XbBx2UVV
`2im`M 7 Hb2c ff
B7 UpBbBi2/(t)(v)V `2im`M 7 Hb2c ff
B7 U#Q `/(t)(v) 54 rQ`/(BM/2t)V `2im`M 7 Hb2c ff
pBbBi2/(t)(v) 4 i`m2c
#QQH `2i 4 /7bU#Q `/- rQ`/- BM/2t Y
/7bU#Q `/- rQ`/- BM/2t Y R/7bU#Q `/- rQ`/- BM/2t Y R/7bU#Q `/- rQ`/- BM/2t Y RpBbBi2/(t)(v) 4 7 Hb2c
R- t @
t Y Rt- v @
t- v Y
RvRR-
v- pBbBi2/V %% ff
pBbBi2/V
%% ff
pBbBi2/V
%% ff
pBbBi2/Vc
ff
195
10.12
'c
'
`2im`M `2ic
10.12
10.12.1
10.12.2
1.
(a)
T i?()
(b)
2.
3.
bi`m+i
bi`m+i
4.
196
10
5.
0
6.
T i?()
7.
(a)
DAG
BFS
BFS
DAG
(b)
9.4
DAG
8
8.
(a)
(b)
i.
DAG
DAG=>
=>
ii.
HashMap
C++
K T
HashMap
mMQ`/2`2/nK T
C++ 11
K T
197
10.12
10.12.3
dfs_template.cpp
/7b
X
!T ` K(BM) BMTmi
!T ` K(Qmi) T i?
!T ` K(Qmi) `2bmHi
!T ` K(BMQmi) +m` Q` ; T
!`2im`M
f
pQB/ /7bUivT2 BMTmi- ivT2 T i?- ivT2 `2bmHi- BMi +m` Q` ; TV &
B7 U
V `2im`M yc
ff
B7 U+m` 44 BMTmiXbBx2UVV & ff
ff B7 U; T 44 yV &
T i?
`2bmHi
'
B7 U
V `2im`Mc
7Q`UXXXV & ff
'
'
T i?
/7bUBMTmi- bi2T Y R Q` ; T@@- `2bmHiVc
T i?
dfs_template.cpp
10.12.4
(Depth-first search, DFS)
http://en.wikipedia.org/wiki/Depth_rst_search
http://en.wikipedia.org/wiki/Backtracking
ing)
=
+
(recursion)
10.12.5
(recursion)
(iteration)
(prunning)
(backtrack-
198
10
+
memorization
memorization
Donald Michie
top-down with cache
??
1968
top-down
memorization
rization
(iterative)
memorization
memorization
memorization
memo-
11
11.1 Pow(x,n)
Implement pow(x, n).
xn = xn/2 xn/2 xn%2
ffG22i*Q/2- SQrUt- MV
ff
0t M 4 t &Mfk'
t &Mfk'
t &M$Wk'0
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
/Qm#H2 KvSQrU/Qm#H2 t- BMi MV &
B7 UM I yV `2im`M RXy f TQr2`Ut- @MVc
2Hb2 `2im`M TQr2`Ut- MVc
'
T`Bp i2,
/Qm#H2 TQr2`U/Qm#H2 t- BMi MV &
B7 UM 44 yV `2im`M Rc
/Qm#H2 p 4 TQr2`Ut- M f kVc
B7 UM W k 44 yV `2im`M p
pc
2Hb2 `2im`M p
p
tc
'
'c
Sqrt(x)
11.2
199
200
11
11.2 Sqrt(x)
Implement int b[`iUBMi tV.
Compute and return the square root of t.
ff G22i*Q/2- a[`iUtV
ff
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi Kva[`iUBMi tV &
BMi H27i 4 R- `B;?i 4 t f kc
BMi H binKB/c ff
KB/
B7 Ut I kV `2im`M tc
'c
'
r?BH2UH27i I4 `B;?iV &
+QMbi BMi KB/ 4 H27i Y U`B;?i @ H27iV f kc
B7Ut f KB/ = KB/V & ff
t = KB/
KB/
H27i 4 KB/ Y Rc
H binKB/ 4 KB/c
' 2Hb2 B7Ut f KB/ I KB/V &
`B;?i 4 KB/ @ Rc
' 2Hb2 &
`2im`M KB/c
'
'
`2im`M H binKB/c
Pow(x)
11.1
12
12.1 Jump Game
Given an array of non-negative integers, you are initially positioned at the first index of the array.
Each element in the array represents your maximum jump length at that position.
Determine if you are able to reach the last index.
For example:
4 (k-j-R-R-9), return true.
4 (j-k-R-y-9), return false.
(B)
0
0
7(B)
f [i] = max(f [i 1], A[i 1]) 1, i > 0
1
ff G22i*Q/2- CmKT : K2
ff
R
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH + MCmKTU+QMbi p2+iQ`IBMi= MmKbV &
BMi `2 +? 4 Rc ff
7Q` UBMi B 4 yc B I `2 +? `2 +? I MmKbXbBx2UVc YYBV
`2 +? 4 K tU`2 +?- B Y R Y MmKb(B)Vc
201
(B)
202
12
'c
'
`2im`M `2 +? =4 MmKbXbBx2UVc
2
ff G22i*Q/2- CmKT : K2
ff
k
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH + MCmKT U+QMbi p2+iQ`IBMi= MmKbV &
B7 UMmKbX2KTivUVV `2im`M i`m2c
ff
BMi H27inKQbi 4 MmKbXbBx2UV @ Rc
7Q` UBMi B 4 MmKbXbBx2UV @ kc B =4 yc @@BV
B7 UB Y MmKb(B) =4 H27inKQbiV
H27inKQbi 4 Bc
'c
'
`2im`M H27inKQbi 44 yc
3
ff G22i*Q/2- CmKT : K2
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH + MCmKTU+QMbi p2+iQ`IBMi= MmKbV &
p2+iQ`IBMi= 7UMmKbXbBx2UV- yVc
7(y) 4 yc
7Q` UBMi B 4 Rc B I MmKbXbBx2UVc BYYV &
7(B) 4 K tU7(B @ R)- MmKb(B @ R)V @ Rc
B7 U7(B) I yV `2im`M 7 Hb2cc
'
`2im`M 7(MmKbXbBx2UV @ R) =4 yc
'
'c
Jump Game II
12.2
12.2 Jump Game II
Given an array of non-negative integers, you are initially positioned at the first index of the array.
12.2 Jump Game II
203
Each element in the array represents your maximum jump length at that position.
Your goal is to reach the last index in the minimum number of jumps.
For example: Given array 4 (k-j-R-R-9)
The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps
to the last index.)
1
ff G22i*Q/2- CmKT : K2 AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi DmKTU+QMbi p2+iQ`IBMi= MmKbV &
BMi bi2T 4 yc ff
BMi H27i 4 yc
BMi `B;?i 4 yc ff (H27i- `B;?i)
B7 UMmKbXbBx2UV 44 RV `2im`M yc
r?BH2 UH27i I4 `B;?iV & ff
YYbi2Tc
+QMbi BMi QH/n`B;?i 4 `B;?ic
7Q` UBMi B 4 H27ic B I4 QH/n`B;?ic YYBV &
BMi M2rn`B;?i 4 B Y MmKb(B)c
B7 UM2rn`B;?i =4 MmKbXbBx2UV @ RV `2im`M bi2Tc
B7 UM2rn`B;?i = `B;?iV `B;?i 4 M2rn`B;?ic
'
H27i 4 QH/n`B;?i Y Rc
'c
'
'
`2im`M yc
2
ff G22i*Q/2- CmKT : K2 AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi DmKTU+QMbi p2+iQ`IBMi= MmKbV &
BMi `2bmHi 4 yc
ff i?2 K tBKmK /Bbi M+2 i? i ? b #22M `2 +?2/
BMi H bi 4 yc
ff i?2 K tBKmK /Bbi M+2 i? i + M #2 `2 +?2/ #v mbBM; ]`2iYR] bi2Tb
BMi +m` 4 yc
204
12
7Q` UBMi B 4 yc B I MmKbXbBx2UVc YYBV &
B7 UB = H biV &
H bi 4 +m`c
YY`2bmHic
'
+m` 4 K tU+m`- B Y MmKb(B)Vc
'
'c
'
`2im`M `2bmHic
Jump Game
12.1
12.3 Best Time to Buy and Sell Stock
Say you have an array for which the i-th element is the price of a given stock on day i.
If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the
stock), design an algorithm to find the maximum profit.
ff G22i*Q/2- "2bi hBK2 iQ "mv M/ a2HH aiQ+F
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tS`Q7BiUp2+iQ`IBMi= T`B+2bV &
B7 UT`B+2bXbBx2UV I kV `2im`M yc
BMi T`Q7Bi 4 yc ff
BMi +m`nKBM 4 T`B+2b(y)c ff
'c
'
7Q` UBMi B 4 Rc B I T`B+2bXbBx2UVc BYYV &
T`Q7Bi 4 K tUT`Q7Bi- T`B+2b(B) @ +m`nKBMVc
+m`nKBM 4 KBMU+m`nKBM- T`B+2b(B)Vc
'
`2im`M T`Q7Bic
m=1
205
12.4 Best Time to Buy and Sell Stock II
Best Time to Buy and Sell Stock II
12.4
Best Time to Buy and Sell Stock III
13.5
12.4 Best Time to Buy and Sell Stock II
Say you have an array for which the i-th element is the price of a given stock on day i.
Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie,
buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions
at the same time (ie, you must sell the stock before you buy again).
ff G22i*Q/2- "2bi hBK2 iQ "mv M/ a2HH aiQ+F AA
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tS`Q7BiUp2+iQ`IBMi= T`B+2bV &
BMi bmK 4 yc
7Q` UBMi B 4 Rc B I T`B+2bXbBx2UVc BYYV &
BMi /B77 4 T`B+2b(B) @ T`B+2b(B @ R)c
B7 U/B77 = yV bmK Y4 /B77c
'
`2im`M bmKc
'
'c
Best Time to Buy and Sell Stock
Best Time to Buy and Sell Stock III
12.3
13.5
m=
206
12
12.5 Longest Substring Without Repeating Characters
Given a string, find the length of the longest substring without repeating characters. For example, the
longest substring without repeating letters for ] #+ #+##] is ] #+], which the length is 3. For ]#####] the
longest substring is ]#], with the length of 1.
BM/2tYR
12-1
O(n)
12-1
ff G22i*Q/2- GQM;2bi am#bi`BM; qBi?Qmi _2T2 iBM; *? ` +i2`b
ff
PUMV
PURV
ff
+H bb aQHmiBQM &
Tm#HB+,
BMi H2M;i?P7GQM;2biam#bi`BM;Ubi`BM; bV &
+QMbi BMi a*AAnJs 4 k88c
BMi H bi(a*AAnJs)c ff
BMi bi `i 4 yc ff
7BHHUH bi- H bi Y a*AAnJs- @RVc ff y
BMi K tnH2M 4 yc
7Q` UBMi B 4 yc B I bXbBx2UVc BYYV &
B7 UH bi(b(B)) =4 bi `iV &
K tnH2M 4 K tUB @ bi `i- K tnH2MVc
bi `i 4 H bi(b(B)) Y Rc
'
H bi(b(B)) 4 Bc
'
@R
207
12.6 Container With Most Water
'
'c
`2im`M K tUUBMiVbXbBx2UV @ bi `i- K tnH2MVc
ff
] #+/]
12.6 Container With Most Water
Given n non-negative integers a1 , a2 , ..., an , where each represents a point at coordinate (i, ai ). n vertical lines are drawn such that the two endpoints of line i is at (i, ai ) and (i, 0). Find two lines, which together
with x-axis forms a container, such that the container contains the most water.
Note: You may not slant the container.
ff G22i*Q/2- *QMi BM2` qBi? JQbi q i2`
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi K t`2 Up2+iQ`IBMi= ?2B;?iV &
BMi bi `i 4 yc
BMi 2M/ 4 ?2B;?iXbBx2UV @ Rc
BMi `2bmHi 4 ALhnJALc
r?BH2 Ubi `i I 2M/V &
BMi `2 4 KBMU?2B;?i(2M/)- ?2B;?i(bi `i)V
`2bmHi 4 K tU`2bmHi- `2 Vc
B7 U?2B;?i(bi `i) I4 ?2B;?i(2M/)V &
bi `iYYc
' 2Hb2 &
2M/@@c
'
'
`2im`M `2bmHic
'
'c
Trapping Rain Water,
2.1.15
U2M/ @ bi `iVc
208
12
Largest Rectangle in Histogram,
4.1.3
13
13.1 Triangle
Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent
numbers on the row below.
For example, given the following triangle
(
(k)(j-9)(e-8-d)(9-R-3-j)
The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).
Note: Bonus point if you are able to do this using only O(n) extra space, where n is the total number of
rows in the triangle.
f (i, j)
(i, j)
f (i, j) = min {f (i + 1, j), f (i + 1, j + 1)} + (i, j)
ff G22i*Q/2- h`B M;H2
ff
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi KBMBKmKhQi H Up2+iQ`Ip2+iQ`IBMi== i`B M;H2V &
7Q` UBMi B 4 i`B M;H2XbBx2UV @ kc B =4 yc @@BV
7Q` UBMi D 4 yc D I B Y Rc YYDV
i`B M;H2(B)(D) Y4 KBMUi`B M;H2(B Y R)(D)i`B M;H2(B Y R)(D Y R)Vc
209
210
13
'
'c
`2im`M i`B M;H2 (y)(y)c
13.2 Maximum Subarray
Find the contiguous subarray within an array (containing at least one number) which has the largest sum.
For example, given the array (k-R-j-9-R-k-R-8-9), the contiguous subarray (9-R-k-R) has
the largest bmK 4 e.
SubArray
2.
SubArray
SubArray
SubArray
SubArray
SubArray
7(D)
a(D)
f [j]
max {f [j 1] + S[j], S[j]} ,
target
max {f [j]} ,
1jn
1jn
S[j]
f [j 1] +
S[j]
S[j]
S[j]
i
S[j]
O(n3 )
O(n2 )
O(n log n)
2O(n2 )
M=1
O(n)
M
211
13.2 Maximum Subarray
ff G22i*Q/2- J tBKmK am# `` v
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tam#`` vUp2+iQ`IBMi= MmKbV &
BMi `2bmHi 4 ALhnJAL- 7 4 yc
7Q` UBMi B 4 yc B I MmKbXbBx2UVc YYBV &
7 4 K tU7 Y MmKb(B)- MmKb(B)Vc
`2bmHi 4 K tU`2bmHi- 7Vc
'
`2im`M `2bmHic
'
'c
5
ff G22i*Q/2- J tBKmK am# `` v
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tam#`` vUp2+iQ`IBMi= V &
`2im`M K+bbUX#2;BMUV- X2M/UVVc
'
T`Bp i2,
ff
8
i2KTH i2 IivT2M K2 Ai2`=
bi iB+ BMi K+bbUAi2` #2;BM- Ai2` 2M/V &
BMi `2bmHi- +m`nKBMc
+QMbi BMi M 4 /Bbi M+2U#2;BM- 2M/Vc
BMi bmK 4 M2r BMi(M Y R)c ff
M
'c
'
bmK(y) 4 yc
`2bmHi 4 ALhnJALc
+m`nKBM 4 bmK(y)c
7Q` UBMi B 4 Rc B I4 Mc BYYV &
bmK(B) 4 bmK(B @ R) Y U#2;BM Y B @ RVc
'
7Q` UBMi B 4 Rc B I4 Mc BYYV &
`2bmHi 4 K tU`2bmHi- bmK(B) @ +m`nKBMVc
+m`nKBM 4 KBMU+m`nKBM- bmK(B)Vc
'
/2H2i2() bmKc
`2im`M `2bmHic
Binary Tree Maximum Path Sum
5.4.5
212
13
13.3 Palindrome Partitioning II
Given a string s, partition s such that every substring of the partition is a palindrome.
Return the minimum cuts needed for a palindrome partitioning of s.
For example, given b 4 ] #],
Return 1 since the palindrome partitioning (] ]-]#]) could be produced using 1 cut.
7UB-DV
(B-D)
cut
f (i, j) = min {f (i, k) + f (k + 1, j)} , i k j, 0 i j < n
DP
7UBV4
(B- M@R)
DP
+mi
f (i) = min {f (j + 1) + 1} , i j < n
(B-D)
DP
S(B)(D) 4 i`m2 B7 (B-D)
S(B)(D) 4 bi`(B) 44 bi`(D) S(BYR)(D@R)
ff G22i*Q/2- S HBM/`QK2 S `iBiBQMBM; AA
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
BMi KBM*miU+QMbi bi`BM; bV &
+QMbi BMi M 4 bXbBx2UVc
BMi 7(MYR)c
#QQH T(M)(M)c
7BHHnMU T(y)(y)- M
M- 7 Hb2Vc
ffi?2 rQ`bi + b2 Bb +miiBM; #v 2 +? +? `
7Q` UBMi B 4 yc B I4 Mc BYYV
7(B) 4 M @ R @ Bc ff
7(M)4@R
7Q` UBMi B 4 M @ Rc B =4 yc B@@V &
7Q` UBMi D 4 Bc D I Mc DYYV &
B7 Ub(B) 44 b(D) UD @ B I k %% T(B Y R)(D @ R)VV &
T(B)(D) 4 i`m2c
7(B) 4 KBMU7(B)- 7(D Y R) Y RVc
'
'
213
13.4 Maximal Rectangle
'c
'
'
`2im`M 7(y)c
Palindrome Partitioning
10.1
13.4 Maximal Rectangle
Given a 2D binary matrix filled with 0s and 1s, find the largest rectangle containing all ones and return
its area.
ff G22i*Q/2- J tBK H _2+i M;H2
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tBK H_2+i M;H2Up2+iQ`Ip2+iQ`I+? `= = K i`BtV &
B7 UK i`BtX2KTivUVV `2im`M yc
+QMbi BMi K
+QMbi BMi M
p2+iQ`IBMi=
p2+iQ`IBMi=
p2+iQ`IBMi=
4 K i`BtXbBx2UVc
4 K i`Bt(y)XbBx2UVc
>UM- yVc
GUM- yVc
_UM- MVc
BMi `2i 4 yc
7Q` UBMi B 4 yc B I Kc YYBV &
BMi H27i 4 y- `B;?i 4 Mc
ff + H+mH i2 GUB- DV 7`QK H27i iQ `B;?i
7Q` UBMi D 4 yc D I Mc YYDV &
B7 UK i`Bt(B)(D) 44 ^R^V &
YY>(D)c
G(D) 4 K tUG(D)- H27iVc
' 2Hb2 &
H27i 4 DYRc
>(D) 4 yc G(D) 4 yc _(D) 4 Mc
'
'
214
13
ff + H+mH i2 _UB- DV 7`QK `B;?i iQ H27i
7Q` UBMi D 4 M@Rc D =4 yc @@DV &
B7 UK i`Bt(B)(D) 44 ^R^V &
_(D) 4 KBMU_(D)- `B;?iVc
`2i 4 K tU`2i- >(D) U_(D)@G(D)VVc
' 2Hb2 &
`B;?i 4 Dc
'
'
'
'c
'
`2im`M `2ic
13.5 Best Time to Buy and Sell Stock III
Say you have an array for which the i-th element is the price of a given stock on day i.
Design an algorithm to find the maximum profit. You may complete at most two transactions.
Note: You may not engage in multiple transactions at the same time (ie, you must sell the stock before
you buy again).
f (i)
[0, i](0 i n1)
[i, n1](0 i n1)
g(i)
max {f (i) + g(i)} , 0 i n 1
https://gist.github.com/soulmachine/5906637
ff G22i*Q/2- "2bi hBK2 iQ "mv M/ a2HH aiQ+F AAA
ff
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tS`Q7BiUp2+iQ`IBMi= T`B+2bV &
B7 UT`B+2bXbBx2UV I kV `2im`M yc
+QMbi BMi M 4 T`B+2bXbBx2UVc
p2+iQ`IBMi= 7UM- yVc
215
13.6 Interleaving String
p2+iQ`IBMi= ;UM- yVc
7Q` UBMi B 4 R- p HH2v 4 T`B+2b(y)c B I Mc YYBV &
p HH2v 4 KBMUp HH2v- T`B+2b(B)Vc
7(B) 4 K tU7(B @ R)- T`B+2b(B) @ p HH2vVc
'
7Q` UBMi B 4 M @ k- T2 F 4 T`B+2b(M @ R)c B =4 yc @@BV &
T2 F 4 K tUT2 F- T`B+2b(B)Vc
;(B) 4 K tU;(B)- T2 F @ T`B+2b(B)Vc
'
BMi K tnT`Q7Bi 4 yc
7Q` UBMi B 4 yc B I Mc YYBV
K tnT`Q7Bi 4 K tUK tnT`Q7Bi- 7(B) Y ;(B)Vc
'c
'
`2im`M K tnT`Q7Bic
Best Time to Buy and Sell Stock
12.3
Best Time to Buy and Sell Stock II
12.4
13.6 Interleaving String
Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.
For example, Given: bR 4 ] #++]- bk 4 ]/##+ ],
When bj 4 ] /##+#+ +], return true.
When bj 4 ] /### +++], return false.
7(B)(D)
s3
bR(y-B)
bk(y-D)
7(B)(D)47(B@R)(D)
bj(y- BYD)
s2
7(B)(D)47(B)(D@R)
7(B)(D) 4 UbR(B @ R) 44 bj (B Y D @ R) 7(B @ R)(D)V
%% Ubk(D @ R) 44 bj (B Y D @ R) 7(B)(D @ R)Vc
ff G22i*Q/2- AMi2`H2 pBM; ai`BM;
ff
s1
s3
216
13
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbAMi2`H2 p2U+QMbi bi`BM; bR- +QMbi bi`BM; bk- +QMbi bi`BM; bjV &
B7 UbjXH2M;i?UV 54 bRXH2M;i?UV Y bkXH2M;i?UVV
`2im`M 7 Hb2c
'
`2im`M BbAMi2`H2 p2U#2;BMUbRV- 2M/UbRV- #2;BMUbkV- 2M/UbkV#2;BMUbjV- 2M/UbjVVc
i2KTH i2IivT2M K2 AMAi=
#QQH BbAMi2`H2 p2UAMAi 7B`biR- AMAi H biR- AMAi 7B`bik- AMAi H bikAMAi 7B`bij- AMAi H bijV &
B7 U7B`bij 44 H bijV
`2im`M 7B`biR 44 H biR 7B`bik 44 H bikc
'c
'
`2im`M U 7B`biR 44 7B`bij
BbAMi2`H2 p2UM2tiU7B`biRV- H biR- 7B`bik- H bikM2tiU7B`bijV- H bijVV
%% U 7B`bik 44 7B`bij
BbAMi2`H2 p2U7B`biR- H biR- M2tiU7B`bikV- H bikM2tiU7B`bijV- H bijVVc
ff G22i*Q/2- AMi2`H2 pBM; ai`BM;
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbAMi2`H2 p2U+QMbi bi`BM; bR- +QMbi bi`BM; bk- +QMbi bi`BM; bjV &
B7 UbjXH2M;i?UV 54 bRXH2M;i?UV Y bkXH2M;i?UVV
`2im`M 7 Hb2c
p2+iQ`Ip2+iQ`I#QQH== 7UbRXH2M;i?UV Y Rp2+iQ`I#QQH=UbkXH2M;i?UV Y R- i`m2VVc
7Q` UbBx2ni B 4 Rc B I4 bRXH2M;i?UVc YYBV
7(B)(y) 4 7(B @ R)(y) bR(B @ R) 44 bj(B @ R)c
7Q` UbBx2ni B 4 Rc B I4 bkXH2M;i?UVc YYBV
7(y)(B) 4 7(y)(B @ R) bk(B @ R) 44 bj(B @ R)c
7Q` UbBx2ni B 4 Rc B I4 bRXH2M;i?UVc YYBV
7Q` UbBx2ni D 4 Rc D I4 bkXH2M;i?UVc YYDV
7(B)(D) 4 UbR(B @ R) 44 bj(B Y D @ R) 7(B @ R)(D)V
%% Ubk(D @ R) 44 bj(B Y D @ R) 7(B)(D @ R)Vc
'c
'
`2im`M 7(bRXH2M;i?UV)(bkXH2M;i?UV)c
13.7 Scramble String
217
+
ff G22i*Q/2- AMi2`H2 pBM; ai`BM;
ff
Y
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH BbAMi2`H2 p2U+QMbi bi`BM; bR- +QMbi bi`BM; bk- +QMbi bi`BM; bjV &
B7 UbRXH2M;i?UV Y bkXH2M;i?UV 54 bjXH2M;i?UVV
`2im`M 7 Hb2c
B7 UbRXH2M;i?UV I bkXH2M;i?UVV
`2im`M BbAMi2`H2 p2Ubk- bR- bjVc
p2+iQ`I#QQH= 7UbkXH2M;i?UV Y R- i`m2Vc
7Q` UbBx2ni B 4 Rc B I4 bkXH2M;i?UVc YYBV
7(B) 4 bk(B @ R) 44 bj(B @ R) 7(B @ R)c
7Q` UbBx2ni B 4 Rc B I4 bRXH2M;i?UVc YYBV &
7(y) 4 bR(B @ R) 44 bj(B @ R) 7(y)c
'
'
'c
7Q` UbBx2ni D 4 Rc D I4 bkXH2M;i?UVc YYDV
7(D) 4 UbR(B @ R) 44 bj(B Y D @ R) 7(D)V
%% Ubk(D @ R) 44 bj(B Y D @ R) 7(D @ R)Vc
`2im`M 7(bkXH2M;i?UV)c
13.7 Scramble String
Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings
recursively.
Below is one possible representation of bR 4 ];`2 i]:
;`2 i
f
$
;`
2 i
f $
f $
;
` 2
i
f $
i
218
13
To scramble the string, we may choose any non-leaf node and swap its two children.
For example, if we choose the node ];`] and swap its two children, it produces a scrambled string
]`;2 i].
`;2 i
f
$
`;
2 i
f $
f $
`
; 2
i
f $
i
We say that ]`;2 i] is a scrambled string of ];`2 i].
Similarly, if we continue to swap the children of nodes ]2 i] and ] i], it produces a scrambled string
]`;i 2].
`;i 2
f
$
`;
i 2
f $
f $
`
; i 2
f $
i
We say that ]`;i 2] is a scrambled string of ];`2 i].
Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.
string
memorization
scamble
false
HashMap
HashMap
bR(B)
bk(D)
scramble
7(M)(B)(D)' 4 U7(F)(B)(D) 7(M@F)(BYF)(DYF)V
%% U7(F)(B)(DYM@F) 7(M@F)(BYF)(D)V
ff G22i*Q/2- a+` K#H2 ai`BM;
ff
ff
PUM eV
+H bb aQHmiBQM &
K T
7(M)(B)(D)
PURV
mMQ`/2`2/nK T
n
219
13.7 Scramble String
Tm#HB+,
#QQH Bba+` K#H2U+QMbi bi`BM; bR- +QMbi bi`BM; bkV &
`2im`M Bba+` K#H2UbRX#2;BMUV- bRX2M/UV- bkX#2;BMUVVc
'
T`Bp i2,
ivT2/27 bi`BM;,,Bi2` iQ` Ai2` iQ`c
#QQH Bba+` K#H2UAi2` iQ` 7B`biR- Ai2` iQ` H biR- Ai2` iQ` 7B`bikV &
miQ H2M;i? 4 /Bbi M+2U7B`biR- H biRVc
miQ H bik 4 M2tiU7B`bik- H2M;i?Vc
B7 UH2M;i? 44 RV `2im`M
7B`biR 44
7B`bikc
7Q` UBMi B 4 Rc B I H2M;i?c YYBV
B7 UUBba+` K#H2U7B`biR- 7B`biR Y B- 7B`bikV
Bba+` K#H2U7B`biR Y B- H biR- 7B`bik Y BVV
%% UBba+` K#H2U7B`biR- 7B`biR Y B- H bik @ BV
Bba+` K#H2U7B`biR Y B- H biR- 7B`bikVVV
`2im`M i`m2c
'c
'
`2im`M 7 Hb2c
ff G22i*Q/2- a+` K#H2 ai`BM;
ff
PUM jV
PUM jV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bba+` K#H2U+QMbi bi`BM; bR- +QMbi bi`BM; bkV &
+QMbi BMi L 4 bRXbBx2UVc
B7 UL 54 bkXbBx2UVV `2im`M 7 Hb2c
ff 7(M)(B)(D)
M
ff
bk(D)
#QQH 7(L Y R)(L)(L)c
7BHHnMU 7(y)(y)(y)- UL Y RV
bR(B)
b+` K#H2
L
L- 7 Hb2Vc
7Q` UBMi B 4 yc B I Lc BYYV
7Q` UBMi D 4 yc D I Lc DYYV
7(R)(B)(D) 4 bR(B) 44 bk(D)c
7Q` UBMi M 4 Rc M I4 Lc YYMV &
7Q` UBMi B 4 yc B Y M I4 Lc YYBV &
7Q` UBMi D 4 yc D Y M I4 Lc YYDV &
7Q` UBMi F 4 Rc F I Mc YYFV &
B7 UU7(F)(B)(D) 7(M @ F)(B Y F)(D Y F)V %%
U7(F)(B)(D Y M @ F) 7(M @ F)(B Y F)(D)VV &
7(M)(B)(D) 4 i`m2c
#`2 Fc
'
'
'
220
'c
13
'
'
'
`2im`M 7(L)(y)(y)c
+
ff G22i*Q/2- a+` K#H2 ai`BM;
ff
Y
ff
PUM eV
PURV
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bba+` K#H2U+QMbi bi`BM; bR- +QMbi bi`BM; bkV &
`2im`M Bba+` K#H2UbRX#2;BMUV- bRX2M/UV- bkX#2;BMUVVc
'
T`Bp i2,
ivT2/27 bi`BM;,,+QMbinBi2` iQ` Ai2` iQ`c
#QQH Bba+` K#H2UAi2` iQ` 7B`biR- Ai2` iQ` H biR- Ai2` iQ` 7B`bikV &
miQ H2M;i? 4 /Bbi M+2U7B`biR- H biRVc
miQ H bik 4 M2tiU7B`bik- H2M;i?Vc
B7 UH2M;i? 44 RV `2im`M 7B`biR 44 7B`bikc
ff
BMi (ke)c ff
7BHHU- Y ke- yVc
7Q`UBMi B 4 yc B I H2M;i?c BYYV ( U7B`biRYBV@^ ^)YYc
7Q`UBMi B 4 yc B I H2M;i?c BYYV ( U7B`bikYBV@^ ^)@@c
7Q`UBMi B 4 yc B I kec BYYV B7 U(B) 54 yV `2im`M 7 Hb2c
7Q` UBMi B 4 Rc B I H2M;i?c YYBV
B7 UUBba+` K#H2U7B`biR- 7B`biR Y B- 7B`bikV
Bba+` K#H2U7B`biR Y B- H biR- 7B`bik Y BVV
%% UBba+` K#H2U7B`biR- 7B`biR Y B- H bik @ BV
Bba+` K#H2U7B`biR Y B- H biR- 7B`bikVVV
`2im`M i`m2c
'c
'
`2im`M 7 Hb2c
ff G22i*Q/2- a+` K#H2 ai`BM;
ff
YK T
+ +?2
ff
PUM jV
PUM jV- hG1
+H bb aQHmiBQM &
Tm#HB+,
#QQH Bba+` K#H2U+QMbi bi`BM; bR- +QMbi bi`BM; bkV &
+ +?2X+H2 `UVc
`2im`M Bba+` K#H2UbRX#2;BMUV- bRX2M/UV- bkX#2;BMUVVc
'
221
13.7 Scramble String
T`Bp i2,
ivT2/27 bi`BM;,,+QMbinBi2` iQ` Ai2` iQ`c
K TIimTH2IAi2` iQ`- Ai2` iQ`- Ai2` iQ`=- #QQH= + +?2c
#QQH Bba+` K#H2UAi2` iQ` 7B`biR- Ai2` iQ` H biR- Ai2` iQ` 7B`bikV &
miQ H2M;i? 4 /Bbi M+2U7B`biR- H biRVc
miQ H bik 4 M2tiU7B`bik- H2M;i?Vc
B7 UH2M;i? 44 RV `2im`M
7B`biR 44
7B`bikc
7Q` UBMi B 4 Rc B I H2M;i?c YYBV
B7 UU;2iP`lT/ i2U7B`biR- 7B`biR Y B- 7B`bikV
;2iP`lT/ i2U7B`biR Y B- H biR- 7B`bik Y BVV
%% U;2iP`lT/ i2U7B`biR- 7B`biR Y B- H bik @ BV
;2iP`lT/ i2U7B`biR Y B- H biR- 7B`bikVVV
`2im`M i`m2c
'
`2im`M 7 Hb2c
#QQH ;2iP`lT/ i2UAi2` iQ` 7B`biR- Ai2` iQ` H biR- Ai2` iQ` 7B`bikV &
miQ F2v 4 K F2nimTH2U7B`biR- H biR- 7B`bikVc
miQ TQb 4 + +?2X7BM/UF2vVc
'c
'
`2im`M UTQb 54 + +?2X2M/UVV \
TQb@=b2+QM/ , U+ +?2(F2v) 4 Bba+` K#H2U7B`biR- H biR- 7B`bikVVc
ivT2/27 bi`BM;,,+QMbinBi2` iQ` Ai2` iQ`c
ivT2/27 imTH2IAi2` iQ`- Ai2` iQ`- Ai2` iQ`= E2vc
ff
M K2bT +2 bi/ &
i2KTH i2I= bi`m+i ? b?IE2v= &
bBx2ni QT2` iQ`UVU+QMbi E2v tV +QMbi &
Ai2` iQ` 7B`biR- H biR- 7B`bikc
iB2U7B`biR- H biR- 7B`bikV 4 tc
'c
'
'
BMi `2bmHi 4 7B`biRc
`2bmHi 4 `2bmHi
jR Y
`2bmHi 4 `2bmHi
jR Y
`2bmHi 4 `2bmHi
jR Y
`2im`M `2bmHic
H biRc
7B`bikc
UM2tiU7B`bik- /Bbi M+2U7B`biR- H biRV@RVVc
ff G22i*Q/2- a+` K#H2 ai`BM;
ff
YmMQ`/2`2/nK T
+ +?2
K T
ff
PUM jV
PUM jV
+H bb aQHmiBQM &
222
13
Tm#HB+,
mMQ`/2`2/nK TIE2v- #QQH= + +?2c
#QQH Bba+` K#H2U+QMbi bi`BM; bR- +QMbi bi`BM; bkV &
+ +?2X+H2 `UVc
`2im`M Bba+` K#H2UbRX#2;BMUV- bRX2M/UV- bkX#2;BMUVVc
'
#QQH Bba+` K#H2UAi2` iQ` 7B`biR- Ai2` iQ` H biR- Ai2` iQ` 7B`bikV &
miQ H2M;i? 4 /Bbi M+2U7B`biR- H biRVc
miQ H bik 4 M2tiU7B`bik- H2M;i?Vc
B7 UH2M;i? 44 RV
`2im`M 7B`biR 44
7B`bikc
7Q` UBMi B 4 Rc B I H2M;i?c YYBV
B7 UU;2iP`lT/ i2U7B`biR- 7B`biR Y B- 7B`bikV
;2iP`lT/ i2U7B`biR Y B- H biR- 7B`bik Y BVV
%% U;2iP`lT/ i2U7B`biR- 7B`biR Y B- H bik @ BV
;2iP`lT/ i2U7B`biR Y B- H biR- 7B`bikVVV
`2im`M i`m2c
'
`2im`M 7 Hb2c
#QQH ;2iP`lT/ i2UAi2` iQ` 7B`biR- Ai2` iQ` H biR- Ai2` iQ` 7B`bikV &
miQ F2v 4 K F2nimTH2U7B`biR- H biR- 7B`bikVc
miQ TQb 4 + +?2X7BM/UF2vVc
'
'c
`2im`M UTQb 54 + +?2X2M/UVV \
TQb@=b2+QM/ , U+ +?2(F2v) 4 Bba+` K#H2U7B`biR- H biR- 7B`bikVVc
13.8 Minimum Path Sum
Given a m n grid filled with non-negative numbers, find a path from top left to bottom right which
minimizes the sum of all numbers along its path.
Note: You can only move either down or right at any point in time
Unique Paths (
10.2)
223
13.8 Minimum Path Sum
7(B)(D)
(0, 0)
(i, j)
7(B)(D)4KBMU7(B@R)(D)- 7(B)(D@R)VY;`B/(B)(D)
ff G22i*Q/2- JBMBKmK S i? amK
ff
+H bb aQHmiBQM &
Tm#HB+,
BMi KBMS i?amKUp2+iQ`Ip2+iQ`IBMi= = ;`B/V &
+QMbi BMi K 4 ;`B/XbBx2UVc
+QMbi BMi M 4 ;`B/(y)XbBx2UVc
i?Bb@=7 4 p2+iQ`Ip2+iQ`IBMi= =UK- p2+iQ`IBMi=UM- @RVVc
`2im`M /7bU;`B/- K@R- M@RVc
'
T`Bp i2,
p2+iQ`Ip2+iQ`IBMi= = 7c ff
BMi /7bU+QMbi p2+iQ`Ip2+iQ`IBMi= = ;`B/- BMi t- BMi vV &
B7 Ut I y %% v I yV `2im`M ALhnJsc ff
B7 Ut 44 y v 44 yV `2im`M ;`B/(y)(y)c ff
'
'c
`2im`M KBMU;2iP`lT/ i2U;`B/- t @ R- vV;2iP`lT/ i2U;`B/- t- v @ RVV Y ;`B/(t)(v)c
BMi ;2iP`lT/ i2U+QMbi p2+iQ`Ip2+iQ`IBMi= = ;`B/- BMi t- BMi vV &
B7 Ut I y %% v I yV `2im`M ALhnJsc ff
y
B7 U7(t)(v) =4 yV `2im`M 7(t)(v)c
2Hb2 `2im`M 7(t)(v) 4 /7bU;`B/- t- vVc
'
ff G22i*Q/2- JBMBKmK S i? amK
ff
+H bb aQHmiBQM &
Tm#HB+,
BMi KBMS i?amKUp2+iQ`Ip2+iQ`IBMi= = ;`B/V &
B7 U;`B/XbBx2UV 44 yV `2im`M yc
+QMbi BMi K 4 ;`B/XbBx2UVc
+QMbi BMi M 4 ;`B/(y)XbBx2UVc
BMi 7(K)(M)c
7(y)(y) 4 ;`B/(y)(y)c
7Q` UBMi B 4 Rc B I Kc BYYV
7(B)(y) 4 7(B @ R)(y) Y
'
7Q` UBMi B 4 Rc B I Mc BYYV
7(y)(B) 4 7(y)(B @ R) Y
&
;`B/(B)(y)c
&
;`B/(y)(B)c
224
13
'
'c
'
7Q` UBMi B 4 Rc B I Kc BYYV &
7Q` UBMi D 4 Rc D I Mc DYYV &
7(B)(D) 4 KBMU7(B @ R)(D)- 7(B)(D @ R)V Y ;`B/(B)(D)c
'
'
`2im`M 7(K @ R)(M @ R)c
+
ff G22i*Q/2- JBMBKmK S i? amK
ff
Y
+H bb aQHmiBQM &
Tm#HB+,
BMi KBMS i?amKUp2+iQ`Ip2+iQ`IBMi= = ;`B/V &
+QMbi BMi K 4 ;`B/XbBx2UVc
+QMbi BMi M 4 ;`B/(y)XbBx2UVc
BMi 7(M)c
7BHHU7- 7YM- ALhnJsVc ff
7(y) 4 yc
'c
'
ALhnJs
KBM
7Q` UBMi B 4 yc B I Kc BYYV &
7(y) Y4 ;`B/(B)(y)c
7Q` UBMi D 4 Rc D I Mc DYYV &
ff
7(D)
7(D)
7(B((D)
ff
7(D)
7(D)
7(B@R)(D)
7(D) 4 KBMU7(D @ R)- 7(D)V Y ;`B/(B)(D)c
'
'
`2im`M 7(M @ R)c
Unique Paths,
Unique Paths II,
10.2
10.3
13.9 Edit Distance
Given two words rQ`/R and rQ`/k, find the minimum number of steps required to convert rQ`/R to
rQ`/k. (each operation is counted as 1 step.)
You have the following 3 operations permitted on a word:
225
13.9 Edit Distance
Insert a character
Delete a character
Replace a character
7(B)(D)
"(y-D)
(y-B)
"(y-D)
(y-B)
bi`k/
1.
+44/
2.
+54/
7(B)(D)47(B@R)(D@R)
(a)
(b)
(c)
7(B)(D)47(B@R)(D@R)YR
d
7(B)(D)47(B)(D@R)YR
7(B)(D)47(B@R)(D)YR
ff G22i*Q/2- 1/Bi .Bbi M+2
ff
PUM KV
PUM KV
+H bb aQHmiBQM &
Tm#HB+,
BMi KBM.Bbi M+2U+QMbi bi`BM; rQ`/R- +QMbi bi`BM; rQ`/kV &
+QMbi bBx2ni M 4 rQ`/RXbBx2UVc
+QMbi bBx2ni K 4 rQ`/kXbBx2UVc
ff
M
MYR
BMi 7(M Y R)(K Y R)c
7Q` UbBx2ni B 4 yc B I4 Mc BYYV
7(B)(y) 4 Bc
7Q` UbBx2ni D 4 yc D I4 Kc DYYV
7(y)(D) 4 Dc
'c
'
7Q` UbBx2ni B 4 Rc B I4 Mc BYYV &
7Q` UbBx2ni D 4 Rc D I4 Kc DYYV &
B7 UrQ`/R(B @ R) 44 rQ`/k(D @ R)V
7(B)(D) 4 7(B @ R)(D @ R)c
2Hb2 &
BMi KM 4 KBMU7(B @ R)(D)- 7(B)(D @ R)Vc
7(B)(D) 4 R Y KBMU7(B @ R)(D @ R)- KMVc
'
'
'
`2im`M 7(M)(K)c
bi`R+
226
13
+
ff G22i*Q/2- 1/Bi .Bbi M+2
ff
Y
ff
PUM KV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi KBM.Bbi M+2U+QMbi bi`BM; rQ`/R- +QMbi bi`BM; rQ`/kV &
B7 UrQ`/RXH2M;i?UV I rQ`/kXH2M;i?UVV
`2im`M KBM.Bbi M+2UrQ`/k- rQ`/RVc
BMi 7(rQ`/kXH2M;i?UV Y R)c
BMi mTT2`nH27i 4 yc ff
7(B@R)(D@R)
7Q` UbBx2ni B 4 yc B I4 rQ`/kXbBx2UVc YYBV
7(B) 4 Bc
7Q` UbBx2ni B 4 Rc B I4 rQ`/RXbBx2UVc YYBV &
mTT2`nH27i 4 7(y)c
7(y) 4 Bc
7Q` UbBx2ni D 4 Rc D I4 rQ`/kXbBx2UVc YYDV &
BMi mTT2` 4 7(D)c
B7 UrQ`/R(B @ R) 44 rQ`/k(D @ R)V
7(D) 4 mTT2`nH27ic
2Hb2
7(D) 4 R Y KBMUmTT2`nH27i- KBMU7(D)- 7(D @ R)VVc
'
'
'c
'
mTT2`nH27i 4 mTT2`c
`2im`M 7(rQ`/kXH2M;i?UV)c
13.10 Decode Ways
A message containing letters from @w is being encoded to numbers using the following mapping:
^^ @= R
^"^ @= k
XXX
^w^ @= ke
13.11 Distinct Subsequences
227
Given an encoded message containing digits, determine the total number of ways to decode it.
For example, Given encoded message ]Rk], it could be decoded as ]"] (1 2) or ]G] (12).
The number of ways decoding ]Rk] is 2.
Climbing Stairs (
2.1.18)
ff G22i*Q/2- .2+Q/2 q vb
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi MmK.2+Q/BM;bU+QMbi bi`BM; bV &
B7 UbX2KTivUV %% b(y) 44 ^y^V `2im`M yc
BMi T`2p 4 yc
BMi +m` 4 Rc
ff
M
MYR
7Q` UbBx2ni B 4 Rc B I4 bXbBx2UVc YYBV &
B7 Ub(B@R) 44 ^y^V +m` 4 yc
B7 UB I k %% 5Ub(B @ k) 44 ^R^ %%
Ub(B @ k) 44 ^k^ b(B @ R) I4 ^e^VVV
T`2p 4 yc
BMi iKT 4 +m`c
+m` 4 T`2p Y +m`c
T`2p 4 iKTc
'c
'
'
`2im`M +m`c
Climbing Stairs,
2.1.18
13.11 Distinct Subsequences
Given a string S and a string T , count the number of distinct subsequences of T in S.
A subsequence of a string is a new string which is formed from the original string by deleting some (can
be none) of the characters without disturbing the relative positions of the remaining characters. (ie, ]*1] is
a subsequence of ]"*.1] while ]1*] is not).
228
13
Here is an example: S = ]` ###Bi], T = ]` ##Bi]
Return 3.
h(y-D)
f (i, j)
a(B)
a(y-B)
f (i, j) = f (i 1, j)
a(B)
a(B)44h(D)
a(B)
h(D)
f (i, j) =
f (i 1, j) + f (i 1, j 1)
ff G22i*Q/2- .BbiBM+i am#b2[m2M+2b
ff
Y
ff
PUK MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi MmK.BbiBM+iU+QMbi bi`BM; a- +QMbi bi`BM; hV &
p2+iQ`IBMi= 7UhXbBx2UV Y RVc
7(y) 4 Rc
7Q` UBMi B 4 yc B I aXbBx2UVc YYBV &
7Q` UBMi D 4 hXbBx2UV @ Rc D =4 yc @@DV &
7(D Y R) Y4 a(B) 44 h(D) \ 7(D) , yc
'
'
'
'c
`2im`M 7(hXbBx2UV)c
13.12 Word Break
Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated
sequence of one or more dictionary words.
For example, given
s = ]H22i+Q/2],
dict = (]H22i]- ]+Q/2]).
Return true because ]H22i+Q/2] can be segmented as ]H22i +Q/2].
229
13.12 Word Break
f (i)
b(y-B)
f (i) = any_of (f (j)&&s[j + 1, i] dict), 0 j < i
ff G22i*Q/2- qQ`/ "`2 F
ff
ff
PUk MV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH rQ`/"`2 FUbi`BM; b- mMQ`/2`2/nb2iIbi`BM;= /B+iV &
`2im`M /7bUb- /B+i- y- yVc
'
T`Bp i2,
bi iB+ #QQH /7bU+QMbi bi`BM; b- mMQ`/2`2/nb2iIbi`BM;= /B+ibBx2ni bi `i- bBx2ni +m`V &
B7 U+m` 44 bXbBx2UVV &
`2im`M /B+iX7BM/UbXbm#bi`Ubi `i- +m`@bi `iYRVV 54 /B+iX2M/UVc
'
B7 U/7bUb- /B+i- bi `i- +m`YRVV `2im`M i`m2c
B7 U/B+iX7BM/UbXbm#bi`Ubi `i- +m`@bi `iYRVV 54 /B+iX2M/UVV
B7 U/7bUb- /B+i- +m`YR- +m`YRVV `2im`M i`m2c
`2im`M 7 Hb2c
'
'c
ff G22i*Q/2- qQ`/ "`2 F
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
#QQH rQ`/"`2 FUbi`BM; b- mMQ`/2`2/nb2iIbi`BM;= /B+iV &
ff
M
MYR
p2+iQ`I#QQH= 7UbXbBx2UV Y R- 7 Hb2Vc
7(y) 4 i`m2c ff
7Q` UBMi B 4 Rc B I4 bXbBx2UVc YYBV &
7Q` UBMi D 4 B @ Rc D =4 yc @@DV &
B7 U7(D) /B+iX7BM/UbXbm#bi`UD- B @ DVV 54 /B+iX2M/UVV &
7(B) 4 i`m2c
#`2 Fc
'
'
'
`2im`M 7(bXbBx2UV)c
'
'c
230
13
Word Break II,
13.13
13.13 Word Break II
Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word
is a valid dictionary word.
Return all such possible sentences.
For example, given
s = ]+ ib M//Q;],
dict = (]+ i]- ]+ ib]- ] M/]- ]b M/]- ]/Q;]).
A solution is (]+ ib M/ /Q;]- ]+ i b M/ /Q;]).
ff G22i*Q/2- qQ`/ "`2 F AA
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ibi`BM;= rQ`/"`2 FUbi`BM; b- mMQ`/2`2/nb2iIbi`BM;= /B+iV &
ff
M
MYR
p2+iQ`I#QQH= 7UbXH2M;i?UV Y R- 7 Hb2Vc
ff T`2p(B)(D)
i`m2
b(D- BV
D
ff
p2+iQ`Ip2+iQ`I#QQH= = T`2pUbXH2M;i?UV Y R- p2+iQ`I#QQH=UbXH2M;i?UVVVc
7(y) 4 i`m2c
7Q` UbBx2ni B 4 Rc B I4 bXH2M;i?UVc YYBV &
7Q` UBMi D 4 B @ Rc D =4 yc @@DV &
B7 U7(D) /B+iX7BM/UbXbm#bi`UD- B @ DVV 54 /B+iX2M/UVV &
7(B) 4 i`m2c
T`2p(B)(D) 4 i`m2c
'
'
'
p2+iQ`Ibi`BM;= `2bmHic
p2+iQ`Ibi`BM;= T i?c
;2MnT i?Ub- T`2p- bXH2M;i?UV- T i?- `2bmHiVc
`2im`M `2bmHic
'
231
13.13 Word Break II
T`Bp i2,
ff .6a
pQB/ ;2MnT i?U+QMbi bi`BM; b- +QMbi p2+iQ`Ip2+iQ`I#QQH= = T`2pBMi +m`- p2+iQ`Ibi`BM;= T i?- p2+iQ`Ibi`BM;= `2bmHiV &
B7 U+m` 44 yV &
bi`BM; iKTc
7Q` U miQ Bi2` 4 T i?X+`#2;BMUVc Bi2` 54 T i?X+`2M/UVc YYBi2`V
iKT Y4 Bi2` Y ] ]c
iKTX2` b2UiKTX2M/UV @ RVc
`2bmHiXTmb?n# +FUiKTVc
'
7Q` UbBx2ni B 4 yc B I bXbBx2UVc YYBV &
B7 UT`2p(+m`)(B)V &
T i?XTmb?n# +FUbXbm#bi`UB- +m` @ BVVc
;2MnT i?Ub- T`2p- B- T i?- `2bmHiVc
T i?XTQTn# +FUVc
'
'
'
'c
Word Break,
13.12
14
ff
bi`m+i lM/B`2+i2/:` T?LQ/2 &
BMi H #2Hc
p2+iQ`IlM/B`2+i2/:` T?LQ/2 = M2B;?#Q`bc
lM/B`2+i2/:` T?LQ/2UBMi tV , H #2HUtV &'c
'c
14.1 Clone Graph
Clone an undirected graph. Each node in the graph contains a H #2H and a list of its M2B;?#Qm`b.
OJs undirected graph serialization: Nodes are labeled uniquely.
We use O as a separator for each node, and - as a separator for node label and each neighbour of the
node. As an example, consider the serialized graph &y-R-kOR-kOk-k'.
The graph has a total of three nodes, and therefore contains three parts as separated by O.
1. First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
2. Second node is labeled as 1. Connect node 1 to node 2.
3. Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.
Visually, the graph looks like the following:
R
f $
f
$
y @@@ k
f $
$nf
232
14.1 Clone Graph
DFS
ff G22i*Q/2- *HQM2 :` T?
ff .6a
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
lM/B`2+i2/:` T?LQ/2 +HQM2:` T?U+QMbi lM/B`2+i2/:` T?LQ/2 MQ/2V &
B7UMQ/2 44 MmHHTi`V `2im`M MmHHTi`c
ff F2v Bb Q`B;BM H MQ/2 p Hm2 Bb +QTB2/ MQ/2
mMQ`/2`2/nK TI+QMbi lM/B`2+i2/:` T?LQ/2 lM/B`2+i2/:` T?LQ/2 = +QTB2/c
+HQM2UMQ/2- +QTB2/Vc
`2im`M +QTB2/(MQ/2)c
'
T`Bp i2,
ff .6a
bi iB+ lM/B`2+i2/:` T?LQ/2 +HQM2U+QMbi lM/B`2+i2/:` T?LQ/2 MQ/2mMQ`/2`2/nK TI+QMbi lM/B`2+i2/:` T?LQ/2 lM/B`2+i2/:` T?LQ/2 = +QTB2/V &
ff +QTv H`2 /v 2tBbib
B7 U+QTB2/X7BM/UMQ/2V 54 +QTB2/X2M/UVV `2im`M +QTB2/(MQ/2)c
'c
'
lM/B`2+i2/:` T?LQ/2 M2rnMQ/2 4 M2r lM/B`2+i2/:` T?LQ/2UMQ/2@=H #2HVc
+QTB2/(MQ/2) 4 M2rnMQ/2c
7Q` U miQ M#` , MQ/2@=M2B;?#Q`bV
M2rnMQ/2@=M2B;?#Q`bXTmb?n# +FU+HQM2UM#`- +QTB2/VVc
`2im`M M2rnMQ/2c
BFS
ff G22i*Q/2- *HQM2 :` T?
ff "6a
PUMV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
lM/B`2+i2/:` T?LQ/2 +HQM2:` T?U+QMbi lM/B`2+i2/:` T?LQ/2 MQ/2V &
B7 UMQ/2 44 MmHHTi`V `2im`M MmHHTi`c
ff F2v Bb Q`B;BM H MQ/2 p Hm2 Bb +QTB2/ MQ/2
mMQ`/2`2/nK TI+QMbi lM/B`2+i2/:` T?LQ/2 lM/B`2+i2/:` T?LQ/2 = +QTB2/c
ff 2 +? MQ/2 BM [m2m2 Bb H`2 /v +QTB2/ Bib2H7
ff #mi M2B;?#Q`b `2 MQi +QTB2/ v2i
[m2m2I+QMbi lM/B`2+i2/:` T?LQ/2 = [c
[XTmb?UMQ/2Vc
+QTB2/(MQ/2) 4 M2r lM/B`2+i2/:` T?LQ/2UMQ/2@=H #2HVc
r?BH2 U5[X2KTivUVV &
+QMbi lM/B`2+i2/:` T?LQ/2 +m` 4 [X7`QMiUVc
[XTQTUVc
7Q` U miQ M#` , +m`@=M2B;?#Q`bV &
ff +QTv H`2 /v 2tBbib
B7 U+QTB2/X7BM/UM#`V 54 +QTB2/X2M/UVV &
+QTB2/(+m`)@=M2B;?#Q`bXTmb?n# +FU+QTB2/(M#`)Vc
233
234
14
' 2Hb2 &
lM/B`2+i2/:` T?LQ/2 M2rnMQ/2 4
M2r lM/B`2+i2/:` T?LQ/2UM#`@=H #2HVc
+QTB2/(M#`) 4 M2rnMQ/2c
+QTB2/(+m`)@=M2B;?#Q`bXTmb?n# +FUM2rnMQ/2Vc
[XTmb?UM#`Vc
'
'c
'
'
'
`2im`M +QTB2/(MQ/2)c
15
15.1 Reverse Integer
Reverse digits of an integer.
Example1: x = 123, return 321
Example2: x = -123, return -321
Have you thought about this?
Here are some good questions to ask before coding. Bonus points for you if you have already thought
through this!
If the integers last digit is 0, what should the output be? ie, cases such as 10, 100.
Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the
reverse of 1000000003 overflows. How should you handle such cases?
Throw an exception? Good, but what if throwing an exception is not an option? You would then have
to re-design the function (ie, add an extra parameter).
ffG22i*Q/2- _2p2`b2 AMi2;2`
ff
PUHQ;MV
ff
RX
kX
+H bb aQHmiBQM &
Tm#HB+,
BMi `2p2`b2 UBMi tV &
HQM; HQM; ` 4 yc
HQM; HQM; i 4 tc
i 4 i = y \ i , @ic
PURV
U
235
t 4 @kR9d93je93U
@k jRV V
236
15
7Q` Uc ic i f4 RyV
` 4 `
Ry Y i W Ryc
'c
'
#QQH bB;M 4 t = y \ 7 Hb2, i`m2c
B7 U` = kR9d93je9d %% UbB;M ` = kR9d93je93VV &
`2im`M yc
' 2Hb2 &
B7 UbB;MV &
`2im`M @`c
' 2Hb2 &
`2im`M `c
'
'
Palindrome Number,
15.2
15.2 Palindrome Number
Determine whether an integer is a palindrome. Do this without extra space.
Some hints:
Could negative integers be palindromes? (ie, -1)
If you are thinking of converting the integer to string, note the restriction of using extra space.
You could also try reversing an integer. However, if you have solved the problem Reverse Integer,
you know that the reversed integer might overflow. How would you handle such case?
There is a more generic way of solving this problem.
Palindrome
reverse()
ffG22i*Q/2- S HBM/`QK2 LmK#2`
ff
PURV
PURV
+H bb aQHmiBQM &
Tm#HB+,
10
237
15.3 Insert Interval
#QQH BbS HBM/`QK2UBMi tV &
B7 Ut I yV `2im`M 7 Hb2c
BMi / 4 Rc ff /BpBbQ`
r?BH2 Ut f / =4 RyV / 4 Ryc
'c
'
r?BH2 Ut = yV &
BMi [ 4 t f
BMi ` 4 t W
B7 U[ 54 `V
t 4 t W / f
/ f4 Ryyc
'
`2im`M i`m2c
/c ff [mQiB2Mi
Ryc
ff `2K BM/2`
`2im`M 7 Hb2c
Ryc
Reverse Integer,
Valid Palindrome,
15.1
3.1
15.3 Insert Interval
Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).
You may assume that the intervals were initially sorted according to their start times.
Example 1: Given intervals (R-j)-(e-N), insert and merge (k-8) in as (R-8)-(e-N).
Example 2:
Given (R-k)-(j-8)-(e-d)-(3-Ry)-(Rk-Re), insert and merge (9-N) in as
(R-k)-(j-Ry)-(Rk-Re).
This is because the new interval (9-N) overlaps with (j-8)-(e-d)-(3-Ry).
bi`m+i AMi2`p H &
BMi bi `ic
BMi 2M/c
AMi2`p HUV , bi `iUyV- 2M/UyV & '
AMi2`p HUBMi b- BMi 2V , bi `iUbV- 2M/U2V & '
'c
ffG22i*Q/2- AMb2`i AMi2`p H
238
15
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IAMi2`p H= BMb2`iUp2+iQ`IAMi2`p H= BMi2`p Hb- AMi2`p H M2rAMi2`p HV &
p2+iQ`IAMi2`p H=,,Bi2` iQ` Bi 4 BMi2`p HbX#2;BMUVc
r?BH2 UBi 54 BMi2`p HbX2M/UVV &
B7 UM2rAMi2`p HX2M/ I Bi@=bi `iV &
BMi2`p HbXBMb2`iUBi- M2rAMi2`p HVc
`2im`M BMi2`p Hbc
' 2Hb2 B7 UM2rAMi2`p HXbi `i = Bi@=2M/V &
BiYYc
+QMiBMm2c
' 2Hb2 &
M2rAMi2`p HXbi `i 4 KBMUM2rAMi2`p HXbi `i- Bi@=bi `iVc
M2rAMi2`p HX2M/ 4 K tUM2rAMi2`p HX2M/- Bi@=2M/Vc
Bi 4 BMi2`p HbX2` b2UBiVc
'
'
BMi2`p HbXBMb2`iUBMi2`p HbX2M/UV- M2rAMi2`p HVc
`2im`M BMi2`p Hbc
'
'c
Merge Intervals
15.4
15.4 Merge Intervals
Given a collection of intervals, merge all overlapping intervals.
For example, Given (R-j)-(k-e)-(3-Ry)-(R8-R3), return (R-e)-(3-Ry)-(R8-R3)
Insert Intervals
interval
interval
bi`m+i AMi2`p H &
BMi bi `ic
BMi 2M/c
AMi2`p HUV , bi `iUyV- 2M/UyV & '
AMi2`p HUBMi b- BMi 2V , bi `iUbV- 2M/U2V & '
'c
15.5 Minimum Window Substring
239
ffG22i*Q/2- J2`;2 AMi2`p H
ff
AMb2`i AMi2`p Hb
ff
PUMRYMkYXXXV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IAMi2`p H= K2`;2Up2+iQ`IAMi2`p H= BMi2`p HbV &
p2+iQ`IAMi2`p H= `2bmHic
7Q` UBMi B 4 yc B I BMi2`p HbXbBx2UVc BYYV &
BMb2`iU`2bmHi- BMi2`p Hb(B)Vc
'
`2im`M `2bmHic
'
T`Bp i2,
p2+iQ`IAMi2`p H= BMb2`iUp2+iQ`IAMi2`p H= BMi2`p Hb- AMi2`p H M2rAMi2`p HV &
p2+iQ`IAMi2`p H=,,Bi2` iQ` Bi 4 BMi2`p HbX#2;BMUVc
r?BH2 UBi 54 BMi2`p HbX2M/UVV &
B7 UM2rAMi2`p HX2M/ I Bi@=bi `iV &
BMi2`p HbXBMb2`iUBi- M2rAMi2`p HVc
`2im`M BMi2`p Hbc
' 2Hb2 B7 UM2rAMi2`p HXbi `i = Bi@=2M/V &
BiYYc
+QMiBMm2c
' 2Hb2 &
M2rAMi2`p HXbi `i 4 KBMUM2rAMi2`p HXbi `i- Bi@=bi `iVc
M2rAMi2`p HX2M/ 4 K tUM2rAMi2`p HX2M/- Bi@=2M/Vc
Bi 4 BMi2`p HbX2` b2UBiVc
'
'
BMi2`p HbXBMb2`iUBMi2`p HbX2M/UV- M2rAMi2`p HVc
`2im`M BMi2`p Hbc
'
'c
Insert Interval
15.3
15.5 Minimum Window Substring
Given a string S and a string T , find the minimum window in S which will contain all the characters in
T in complexity O(n).
For example, a 4 ].P"1*P.1"L*]- h 4 ]"*]
Minimum window is ]"L*].
Note:
If there is no such window in S that covers all characters in T , return the emtpy string ]].
240
15
If there are multiple such windows, you are guaranteed that there will always be only one unique
minimum window in S.
ff G22i*Q/2- JBMBKmK qBM/Qr am#bi`BM;
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; KBMqBM/QrUbi`BM; a- bi`BM; hV &
B7 UaX2KTivUVV `2im`M ]]c
B7 UaXbBx2UV I hXbBx2UVV `2im`M ]]c
+QMbi BMi a*AAnJs 4 k8ec
BMi TT2 `2/n+QmMi(a*AAnJs)c
BMi 2tT2+i2/n+QmMi(a*AAnJs)c
7BHHU TT2 `2/n+QmMi- TT2 `2/n+QmMi Y a*AAnJs- yVc
7BHHU2tT2+i2/n+QmMi- 2tT2+i2/n+QmMi Y a*AAnJs- yVc
7Q` UbBx2ni B 4 yc B I hXbBx2UVc BYYV 2tT2+i2/n+QmMi(h(B))YYc
BMi
BMi
BMi
ff
7Q`
'
KBMqB/i? 4 ALhnJs- KBMnbi `i 4 yc
rM/nbi `i 4 yc
TT2 `2/ 4 yc ff
h
ff
UbBx2ni rM/n2M/ 4 yc rM/n2M/ I aXbBx2UVc rM/n2M/YYV &
B7 U2tT2+i2/n+QmMi(a(rM/n2M/)) = yV & ff i?Bb +? ` Bb T `i Q7 h
TT2 `2/n+QmMi(a(rM/n2M/))YYc
B7 U TT2 `2/n+QmMi(a(rM/n2M/)) I4 2tT2+i2/n+QmMi(a(rM/n2M/))V
TT2 `2/YYc
'
B7 U TT2 `2/ 44 hXbBx2UVV & ff
h
ff
r?BH2 U TT2 `2/n+QmMi(a(rM/nbi `i)) = 2tT2+i2/n+QmMi(a(rM/nbi `i))
%% 2tT2+i2/n+QmMi(a(rM/nbi `i)) 44 yV &
TT2 `2/n+QmMi(a(rM/nbi `i))@@c
rM/nbi `iYYc
'
B7 UKBMqB/i? = UrM/n2M/ @ rM/nbi `i Y RVV &
KBMqB/i? 4 rM/n2M/ @ rM/nbi `i Y Rc
KBMnbi `i 4 rM/nbi `ic
'
'
B7 UKBMqB/i? 44 ALhnJsV `2im`M ]]c
241
15.6 Multiply Strings
'
'c
2Hb2 `2im`M aXbm#bi`UKBMnbi `i- KBMqB/i?Vc
15.6 Multiply Strings
Given two numbers represented as strings, return multiplication of the numbers as a string.
Note: The numbers can be arbitrarily large and are non-negative.
int
int32
31
int
9
1 = 2147483647
int64
1
ff G22i*Q/2- JmHiBTHv ai`BM;b
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHB M+?2M;xDmV
ff
BMi
ff
PUM KV
PUMYKV
ivT2/27 p2+iQ`IBMi= #B;BMic
#B;BMi K F2n#B;BMiUbi`BM; +QMbi `2T`V &
#B;BMi Mc
i` Mb7Q`KU`2T`X`#2;BMUV- `2T`X`2M/UV- # +FnBMb2`i2`UMV()U+? ` +V & `2im`M + @ ^y^c 'Vc
`2im`M Mc
'
bi`BM; iQnbi`BM;U#B;BMi +QMbi MV
bi`BM; bi`c
i` Mb7Q`KU7BM/nB7UMX`#2;BMUV()U+? ` +V & `2im`M +
()U+? ` +V & `2im`M +
`2im`M bi`c
'
&
T`2pUMX`2M/UVV= ^$y^c 'V- MX`2M/UV- # +FnBMb2`i2`Ubi`VY ^y^c 'Vc
#B;BMi QT2` iQ` U#B;BMi +QMbi t- #B;BMi +QMbi vV &
#B;BMi xUtXbBx2UV Y vXbBx2UVVc
242
15
7Q` UbBx2ni B 4 yc B I tXbBx2UVc YYBV
7Q` UbBx2ni D 4 yc D I vXbBx2UVc YYDV &
x(B Y D) Y4 t(B)
v(D)c
x(B Y D Y R) Y4 x(B Y D) f Ryc
x(B Y D) W4 Ryc
'
'
`2im`M xc
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; KmHiBTHvUbi`BM; MmKR- bi`BM; MmKkV &
`2im`M iQnbi`BM;UK F2n#B;BMiUMmKRV
K F2n#B;BMiUMmKkVVc
'
'c
2
ff G22i*Q/2- JmHiBTHv ai`BM;b
ff N
BMie9ni
ff
PUM Kf3RV
PUUMYKVfNV
f
X f
+H bb "B;AMi &
Tm#HB+,
f
!#`B27
X
!T ` K(BM) b
!`2im`M
f
"B;AMiUbi`BM; bV &
p2+iQ`IBMie9ni= `2bmHic
`2bmHiX`2b2`p2UbXbBx2UV f _.AsnG1L Y RVc
'
f
7Q` UBMi B 4 bXbBx2UVc B = yc B @4 _.AsnG1LV &
BMi i2KT 4 yc
+QMbi BMi HQr 4 K tUB @ _.AsnG1L- yVc
7Q` UBMi D 4 HQrc D I Bc DYYV &
i2KT 4 i2KT
Ry Y b(D) @ ^y^c
'
`2bmHiXTmb?n# +FUi2KTVc
'
2H2Kb 4 `2bmHic
ff (B@_.AsnG1L- BV
!#`B27
X
!`2im`M
f
bi`BM; iQai`BM;UV &
bi`BM;bi`2 K `2bmHic
#QQH bi `i2/ 4 7 Hb2c ff
y
7Q` U miQ B 4 2H2KbX`#2;BMUVc B 54 2H2KbX`2M/UVc BYYV &
243
15.6 Multiply Strings
'
'
B7 Ubi `i2/V & ff
y
`2bmHi II b2irU_.AsnG1LV II b2i7BHHU^y^V II
' 2Hb2 &
`2bmHi II Bc
bi `i2/ 4 i`m2c ff
y
'
B7 U5bi `i2/V `2im`M ]y]c ff
2Hb2 `2im`M `2bmHiXbi`UVc
Bc
y
!#`B27
X
!T ` K(BM) t t
!T ` K(BM) v v
!`2im`M
f
bi iB+ "B;AMi KmHiBTHvU+QMbi "B;AMi t- +QMbi "B;AMi vV &
p2+iQ`IBMie9ni= xUtX2H2KbXbBx2UV Y vX2H2KbXbBx2UV- yVc
7Q` UbBx2ni B 4 yc B I vX2H2KbXbBx2UVc BYYV &
7Q` UbBx2ni D 4 yc D I tX2H2KbXbBx2UVc DYYV & ff
ff
B- D
BYD
x(B Y D) Y4 vX2H2Kb(B)
tX2H2Kb(D)c
v(B)
B7 Ux(B Y D) =4 "A:ALhn_.AsV & ff
x(B Y D Y R) Y4 x(B Y D) f "A:ALhn_.Asc ff
x(B Y D) W4 "A:ALhn_.Asc
'
'
'
'
r?BH2 UxX# +FUV 44 yV xXTQTn# +FUVc
`2im`M "B;AMiUxVc
ff
T`Bp i2,
ivT2/27 HQM; HQM; BMie9nic
f
N
Ryyyyyyyyy
Ryyyyyyyyy
k ej@R
f
+QMbi bi iB+ BMi "A:ALhn_.As 4 Ryyyyyyyyyc
+QMbi bi iB+ BMi _.AsnG1L 4 Nc
f
X f
p2+iQ`IBMie9ni= 2H2Kbc
"B;AMiU+QMbi p2+iQ`IBMie9ni= MmKV , 2H2KbUMmKV &'
'c
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; KmHiBTHvUbi`BM; MmKR- bi`BM; MmKkV &
"B;AMi tUMmKRVc
244
15
'
'c
"B;AMi vUMmKkVc
`2im`M "B;AMi,,KmHiBTHvUt- vVXiQai`BM;UVc
15.7 Substring with Concatenation of All Words
You are given a string, S, and a list of words, L, that are all of the same length. Find all starting indices of
substring(s) in S that is a concatenation of each word in L exactly once and without any intervening characters.
For example, given:
a, ]# `7QQi?27QQ# `K M]
G, (]7QQ]- ]# `])
You should return the indices: (y-N).(order does not matter).
ff G22i*Q/2- am#bi`BM; rBi? *QM+ i2M iBQM Q7 HH qQ`/b
ff
PUM KV
PUKV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= 7BM/am#bi`BM;Ubi`BM; b- p2+iQ`Ibi`BM;= /B+iV &
bBx2ni rQ`/G2M;i? 4 /B+iX7`QMiUVXH2M;i?UVc
bBx2ni + iG2M;i? 4 rQ`/G2M;i?
/B+iXbBx2UVc
p2+iQ`IBMi= `2bmHic
B7 UbXH2M;i?UV I + iG2M;i?V `2im`M `2bmHic
mMQ`/2`2/nK TIbi`BM;- BMi= rQ`/*QmMic
7Q` U miQ +QMbi rQ`/ , /B+iV YYrQ`/*QmMi(rQ`/)c
7Q` U miQ B 4 #2;BMUbVc B I4 T`2pU2M/UbV- + iG2M;i?Vc YYBV &
mMQ`/2`2/nK TIbi`BM;- BMi= mMmb2/UrQ`/*QmMiVc
7Q` U miQ D 4 Bc D 54 M2tiUB- + iG2M;i?Vc D Y4 rQ`/G2M;i?V &
miQ TQb 4 mMmb2/X7BM/Ubi`BM;UD- M2tiUD- rQ`/G2M;i?VVVc
245
15.8 Pascals Triangle
B7 UTQb 44 mMmb2/X2M/UV %% TQb@=b2+QM/ 44 yV #`2 Fc
'
'
'
'c
B7 U@@TQb@=b2+QM/ 44 yV mMmb2/X2` b2UTQbVc
B7 UmMmb2/XbBx2UV 44 yV `2bmHiXTmb?n# +FU/Bbi M+2U#2;BMUbV- BVVc
`2im`M `2bmHic
15.8 Pascals Triangle
Given numRows, generate the first numRows of Pascals triangle.
For example, given numRows = 5,
Return
(
(R)(R-R)(R-k-R)(R-j-j-R)(R-9-e-9-R)
ff G22i*Q/2- S b+ H^b h`B M;H2
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = ;2M2` i2UBMi MmK_QrbV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
246
15
B7UMmK_Qrb 44 yV `2im`M `2bmHic
`2bmHiXTmb?n# +FUp2+iQ`IBMi=UR-RVVc ff7B`bi `Qr
7Q`UBMi B 4 kc B I4 MmK_Qrbc YYBV &
p2+iQ`IBMi= +m``2MiUB-RVc ff
+QMbi p2+iQ`IBMi= T`2p 4 `2bmHi(B@k)c
ff
7Q`UBMi D 4 Rc D I B @ Rc YYDV &
+m``2Mi(D) 4 T`2p(D@R) Y T`2p(D)c ff
'
`2bmHiXTmb?n# +FU+m``2MiVc
'c
'
'
`2im`M `2bmHic
ff G22i*Q/2- S b+ H^b h`B M;H2
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = ;2M2` i2UBMi MmK_QrbV &
p2+iQ`Ip2+iQ`IBMi= = `2bmHic
p2+iQ`IBMi= `` vc
7Q` UBMi B 4 Rc B I4 MmK_Qrbc BYYV &
7Q` UBMi D 4 B @ kc D = yc D@@V &
`` v(D) 4 `` v(D @ R) Y `` v(D)c
'
`` vXTmb?n# +FURVc
`2bmHiXTmb?n# +FU `` vVc
'
`2im`M `2bmHic
'
'c
Pascals Triangle II
15.9
15.9 Pascals Triangle II
Given an index k, return the kth row of the Pascals triangle.
For example, given k = 3,
Return (R-j-j-R).
Note: Could you optimize your algorithm to use only O(k) extra space?
247
15.10 Spiral Matrix
ff G22i*Q/2- S b+ H^b h`B M;H2 AA
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= ;2i_QrUBMi `QrAM/2tV &
p2+iQ`IBMi= `` vc
7Q` UBMi B 4 yc B I4 `QrAM/2tc BYYV &
7Q` UBMi D 4 B @ Rc D = yc D@@V&
`` v(D) 4 `` v(D @ R) Y `` v(D)c
'
`` vXTmb?n# +FURVc
'
`2im`M `` vc
'
'c
Pascals Triangle
15.8
15.10 Spiral Matrix
Given a matrix of m n elements (m rows, n columns), return all elements of the matrix in spiral order.
For example, Given the following matrix:
(
( R- k- j )( 9- 8- e )( d- 3- N )
You should return (R-k-j-e-N-3-d-9-8).
248
15
ff G22i*Q/2- aTB` H J i`Bt
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHm M;QM;V
ff
PUM kV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`IBMi= bTB` HP`/2`Up2+iQ`Ip2+iQ`IBMi= = K i`BtV &
p2+iQ`IBMi= `2bmHic
B7 UK i`BtX2KTivUVV `2im`M `2bmHic
BMi #2;BMs 4 y- 2M/s 4 K i`Bt(y)XbBx2UV @ Rc
BMi #2;BMu 4 y- 2M/u 4 K i`BtXbBx2UV @ Rc
r?BH2 Ui`m2V &
ff 6`QK H27i iQ `B;?i
7Q` UBMi D 4 #2;BMsc D I4 2M/sc YYDV `2bmHiXTmb?n# +FUK i`Bt(#2;BMu)(D)Vc
B7 UYY#2;BMu = 2M/uV #`2 Fc
ff 6`QK iQT iQ #QiiQK
7Q` UBMi B 4 #2;BMuc B I4 2M/uc YYBV `2bmHiXTmb?n# +FUK i`Bt(B)(2M/s)Vc
B7 U#2;BMs = @@2M/sV #`2 Fc
ff 6`QK `B;?i iQ H27i
7Q` UBMi D 4 2M/sc D =4 #2;BMsc @@DV `2bmHiXTmb?n# +FUK i`Bt(2M/u)(D)Vc
B7 U#2;BMu = @@2M/uV #`2 Fc
ff 6`QK #QiiQK iQ iQT
7Q` UBMi B 4 2M/uc B =4 #2;BMuc @@BV `2bmHiXTmb?n# +FUK i`Bt(B)(#2;BMs)Vc
B7 UYY#2;BMs = 2M/sV #`2 Fc
'
`2im`M `2bmHic
'
'c
Spiral Matrix II
15.11
15.11 Spiral Matrix II
Given an integer n, generate a square matrix filled with elements from 1 to n2 in spiral order.
For example, Given n = 3,
You should return the following matrix:
(
( R- k- j )( 3- N- 9 )( d- e- 8 )
249
15.11 Spiral Matrix II
1
ff G22i*Q/2- aTB` H J i`Bt AA
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = ;2M2` i2J i`BtUBMi MV &
p2+iQ`Ip2+iQ`IBMi= = K i`BtUM- p2+iQ`IBMi=UMVVc
BMi #2;BM 4 y- 2M/ 4 M @ Rc
BMi MmK 4 Rc
r?BH2 U#2;BM
7Q` UBMi
7Q` UBMi
7Q` UBMi
7Q` UBMi
YY#2;BMc
@@2M/c
'
I
D
B
D
B
2M/V &
4 #2;BMc
4 #2;BMc
4 2M/c D
4 2M/c B
D
B
=
=
I 2M/c
I 2M/c
#2;BMc
#2;BMc
YYDV
YYBV
@@DV
@@BV
K i`Bt(#2;BM)(D)
K i`Bt(B)(2M/) 4
K i`Bt(2M/)(D) 4
K i`Bt(B)(#2;BM)
4 MmKYYc
MmKYYc
MmKYYc
4 MmKYYc
B7 U#2;BM 44 2M/V K i`Bt(#2;BM)(#2;BM) 4 MmKc
'c
'
`2im`M K i`Btc
2
ff G22i*Q/2- aTB` H J i`Bt AA
ff ! mi?Q`
U?iiT,ffr2B#QX+QKfHm M;QM;V
ff
PUM kV
PUM kV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ip2+iQ`IBMi= = ;2M2` i2J i`BtUBMi MV &
p2+iQ`I p2+iQ`IBMi= = K i`BtUM- p2+iQ`IBMi=UMVVc
B7 UM 44 yV `2im`M K i`Btc
BMi #2;BMs 4 y- 2M/s 4 M @ Rc
BMi #2;BMu 4 y- 2M/u 4 M @ Rc
BMi MmK 4 Rc
r?BH2 Ui`m2V &
7Q` UBMi D 4 #2;BMsc D I4 2M/sc YYDV K i`Bt(#2;BMu)(D) 4 MmKYYc
B7 UYY#2;BMu = 2M/uV #`2 Fc
7Q` UBMi B 4 #2;BMuc B I4 2M/uc YYBV K i`Bt(B)(2M/s) 4 MmKYYc
B7 U#2;BMs = @@2M/sV #`2 Fc
7Q` UBMi D 4 2M/sc D =4 #2;BMsc @@DV K i`Bt(2M/u)(D) 4 MmKYYc
B7 U#2;BMu = @@2M/uV #`2 Fc
250
15
7Q` UBMi B 4 2M/uc B =4 #2;BMuc @@BV K i`Bt(B)(#2;BMs) 4 MmKYYc
B7 UYY#2;BMs = 2M/sV #`2 Fc
'c
'
'
`2im`M K i`Btc
Spiral Matrix,
15.10
15.12 ZigZag Conversion
The string ]SuSGAa>A_AL:] is written in a zigzag pattern on a given number of rows like this: (you
may want to display this pattern in a fixed font for better legibility)
S
>
L
S G a A A :
u
A
_
And then read line by line: ]S>LSGaAA:uA_]
Write the code that will take a string and make this conversion given a number of rows:
bi`BM; +QMp2`iUbi`BM; i2ti- BMi M_QrbVc
+QMp2`iU]SuSGAa>A_AL:]- jV should return ]S>LSGaAA:uA_].
n=4:
S
A
L
G a
A :
u
> _
S
A
n=5:
S
>
a A
u
A
_
S G
A
L
:
(i, j) = (j + 1) n + i
(i, j) = (j + 1) n i
251
15.13 Divide Two Integers
ff G22i*Q/2- wB;w ; *QMp2`bBQM
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
bi`BM; +QMp2`iUbi`BM; b- BMi M_QrbV &
B7 UM_Qrb I4 R %% bXbBx2UV I4 RV `2im`M bc
bi`BM; `2bmHic
7Q` UBMi B 4 yc B I M_Qrbc BYYV &
7Q` UBMi D 4 y- BM/2t 4 Bc BM/2t I bXbBx2UVc
DYY- BM/2t 4 Uk
M_Qrb @ kV
D Y BV &
`2bmHiX TT2M/UR- b(BM/2t)Vc ff
B7 UB 44 y %% B 44 M_Qrb @ RV +QMiBMm2c
ff
B7 UBM/2t Y UM_Qrb @ B @ RV
k I bXbBx2UVV
`2bmHiX TT2M/UR- b(BM/2t Y UM_Qrb @ B @ RV
'
'
`2im`M `2bmHic
'
'c
k)Vc
15.13 Divide Two Integers
Divide two integers without using multiplication, division and mod operator.
1
ff G22i*Q/2- .BpB/2 hrQ AMi2;2`b
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi /BpB/2UBMi /BpB/2M/- BMi /BpBbQ`V &
ff
/BpB/2M/ 4 ALhnJAL
@/BpB/2M/
HQM; HQM;
HQM; HQM; 4 /BpB/2M/ =4 y \ /BpB/2M/ , @UHQM; HQM;V/BpB/2M/c
HQM; HQM; # 4 /BpBbQ` =4 y \ /BpBbQ` , @UHQM; HQM;V/BpBbQ`c
252
15
ff
/BpB/2M/ 4 ALhnJAL
/BpBbQ` 4 @R
HQM; HQM; `2bmHi 4 yc
r?BH2 U =4 #V &
HQM; HQM; + 4 #c
7Q` UBMi B 4 yc =4 +c YYB- + II4 RV &
@4 +c
`2bmHi Y4 R II Bc
'
'
'c
'
HQM; HQM;
`2im`M UU/BpB/2M/ /BpBbQ`V == jRV \ U@`2bmHiV , U`2bmHiVc
2
ff G22i*Q/2- .BpB/2 hrQ AMi2;2`b
ff
PUHQ;MV
PURV
+H bb aQHmiBQM &
Tm#HB+,
BMi /BpB/2UBMi /BpB/2M/- BMi /BpBbQ`V &
BMi `2bmHi 4 yc ff
/BpB/2M/ 4 ALhnJAL
/BpBbQ` 4 @R
+QMbi #QQH bB;M 4 U/BpB/2M/ = y /BpBbQ` I yV %%
U/BpB/2M/ I y /BpBbQ` = yVc ff
ff
/BpB/2M/ 4 ALhnJAL
@/BpB/2M/
mMbB;M2/ BMi
mMbB;M2/ BMi 4 /BpB/2M/ =4 y \ /BpB/2M/ , @/BpB/2M/c
mMbB;M2/ BMi # 4 /BpBbQ` =4 y \ /BpBbQ` , @/BpBbQ`c
r?BH2 U =4 #V &
BMi KmHiB 4 Rc
mMbB;M2/ BMi ## 4 #c
r?BH2 U =4 ##V &
@4 ##c
`2bmHi Y4 KmHiBc
B7 U## I ALhnJs == RV & ff
## Y4 ##c
KmHiB Y4 KmHiBc
'
'c
'
'
'
B7 UbB;MV `2im`M @`2bmHic
2Hb2 `2im`M `2bmHic
15.14 Text Justification
253
15.14 Text Justification
Given an array of words and a length L, format the text such that each line has exactly L characters and
is fully (left and right) justified.
You should pack your words in a greedy approach; that is, pack as many words as you can in each line.
Pad extra spaces ^ ^ when necessary so that each line has exactly L characters.
Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a
line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the
slots on the right.
For the last line of text, it should be left justified and no extra space is inserted between words.
For example,
words: (]h?Bb]- ]Bb]- ] M]- ]2t KTH2]- ]Q7]- ]i2ti]- ]DmbiB7B+ iBQMX])
L: 16.
Return the formatted lines as:
(
]h?Bb
Bb
M]]2t KTH2 Q7 i2ti]]DmbiB7B+ iBQMX ]
Note: Each word is guaranteed not to exceed L in length.
Corner Cases:
A line other than the last line might contain only one word. What should you do in this case?
In this case, that line should be left
ff G22i*Q/2- h2ti CmbiB7B+ iBQM
ff
PUMV
PURV
+H bb aQHmiBQM &
Tm#HB+,
p2+iQ`Ibi`BM;= 7mHHCmbiB7vUp2+iQ`Ibi`BM;= rQ`/b- BMi GV &
p2+iQ`Ibi`BM;= `2bmHic
+QMbi BMi M 4 rQ`/bXbBx2UVc
BMi #2;BM 4 y- H2M 4 yc ff
7Q` UBMi B 4 yc B I Mc YYBV &
B7 UH2M Y rQ`/b(B)XbBx2UV Y UB @ #2;BMV = GV &
`2bmHiXTmb?n# +FU+QMM2+iUrQ`/b- #2;BM- B @ R- H2M- G- 7 Hb2VVc
254
15
#2;BM 4 Bc
H2M 4 yc
'
H2M Y4 rQ`/b(B)XbBx2UVc
'
f
'
ff
G
`2bmHiXTmb?n# +FU+QMM2+iUrQ`/b- #2;BM- M @ R- H2M- G- i`m2VVc
`2im`M `2bmHic
!#`B27
rQ`/b(#2;BM- 2M/)
!T ` K(BM) rQ`/b
!T ` K(BM) #2;BM
!T ` K(BM) 2M/
!T ` K(BM) H2M rQ`/b(#2;BM- 2M/)
!T ` K(BM) G
!T ` K(BM) BbnH bi
!`2im`M
f
bi`BM; +QMM2+iUp2+iQ`Ibi`BM;= rQ`/b- BMi #2;BM- BMi 2M/BMi H2M- BMi G- #QQH BbnH biV &
bi`BM; bc
BMi M 4 2M/ @ #2;BM Y Rc
7Q` UBMi B 4 yc B I Mc YYBV &
b Y4 rQ`/b(#2;BM Y B)c
//aT +2bUb- B- M @ R- G @ H2M- BbnH biVc
'
'
f
'c
!#`B27
X
!T ` K(BMQmi)b
!T ` K(BM) B
!T ` K(BM) M
!T ` K(BM) G
!T ` K(BM) BbnH bi
!`2im`M
f
pQB/ //aT +2bUbi`BM; b- BMi B- BMi M- BMi G- #QQH BbnH biV &
B7 UM I R %% B = M @ RV `2im`Mc
BMi bT +2b 4 BbnH bi \ R , UG f M Y UB I UG W MV \ R , yVVc
bX TT2M/UbT +2b- ^ ^Vc
'
B7 UbXbBx2UV I GV bX TT2M/UG @ bXbBx2UV- ^ ^Vc
`2im`M bc
255
15.15 Max Points on a Line
15.15 Max Points on a Line
Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.
n
n
1
n(n + 1)
2
O(n3 )
key
O(n2 )
O(n)
ff G22i*Q/2- J t SQBMib QM GBM2
ff
PUM jV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tSQBMibUp2+iQ`ISQBMi= TQBMibV &
B7 UTQBMibXbBx2UV I jV `2im`M TQBMibXbBx2UVc
BMi `2bmHi 4 yc
'c
value
'
PURV
7Q` UBMi B 4 yc B I TQBMibXbBx2UV @ Rc BYYV &
7Q` UBMi D 4 B Y Rc D I TQBMibXbBx2UVc DYYV &
BMi bB;M 4 yc
BMi - #- +c
B7 UTQBMib(B)Xt 44 TQBMib(D)XtV bB;M 4 Rc
2Hb2 &
4 TQBMib(D)Xt @ TQBMib(B)Xtc
# 4 TQBMib(D)Xv @ TQBMib(B)Xvc
+ 4
TQBMib(B)Xv @ #
TQBMib(B)Xtc
'
BMi +QmMi 4 yc
7Q` UBMi F 4 yc F I TQBMibXbBx2UVc FYYV &
B7 UUy 44 bB;M
TQBMib(F)Xv 44 + Y #
UR 44 bB;M TQBMib(F)Xt 44 TQBMib(D)XtVV
+QmMiYYc
'
B7 U+QmMi = `2bmHiV `2bmHi 4 +QmMic
'
'
`2im`M `2bmHic
TQBMib(F)XtV %%
256
15
ff G22i*Q/2- J t SQBMib QM GBM2
ff
PUM kV
PUMV
+H bb aQHmiBQM &
Tm#HB+,
BMi K tSQBMibUp2+iQ`ISQBMi= TQBMibV &
B7 UTQBMibXbBx2UV I jV `2im`M TQBMibXbBx2UVc
BMi `2bmHi 4 yc
mMQ`/2`2/nK TI/Qm#H2- BMi= bHQT2n+QmMic
7Q` UBMi B 4 yc B I TQBMibXbBx2UV@Rc BYYV &
bHQT2n+QmMiX+H2 `UVc
BMi b K2SQBMiLmK 4 yc ff
B
BMi TQBMinK t 4 Rc
ff
B
7Q` UBMi D 4 B Y Rc D I TQBMibXbBx2UVc DYYV &
/Qm#H2 bHQT2c ff
B7 UTQBMib(B)Xt 44 TQBMib(D)XtV &
bHQT2 4 bi/,,MmK2`B+nHBKBibI/Qm#H2=,,BM7BMBivUVc
B7 UTQBMib(B)Xv 44 TQBMib(D)XvV &
YY b K2SQBMiLmKc
+QMiBMm2c
'
' 2Hb2 &
bHQT2 4 RXy
UTQBMib(B)Xv @ TQBMib(D)XvV f
UTQBMib(B)Xt @ TQBMib(D)XtVc
'
BMi +QmMi 4 yc
B7 UbHQT2n+QmMiX7BM/UbHQT2V 54 bHQT2n+QmMiX2M/UVV
+QmMi 4 YYbHQT2n+QmMi(bHQT2)c
2Hb2 &
+QmMi 4 kc
bHQT2n+QmMi(bHQT2) 4 kc
'
B7 UTQBMinK t I +QmMiV TQBMinK t 4 +QmMic
'
`2bmHi 4 K tU`2bmHi- TQBMinK t Y b K2SQBMiLmKVc
'c
'
'
`2im`M `2bmHic
You might also like
- Complete Data Structures and Algorithms Guide: Resources, Notes, Questions, SolutionsNo ratings yetComplete Data Structures and Algorithms Guide: Resources, Notes, Questions, Solutions100 pages
- Top FAANG Interview Questions From LeetCodeNo ratings yetTop FAANG Interview Questions From LeetCode14 pages
- 1 Cheatsheet: Leetcode Common Templates & Common Code Problems InterviewNo ratings yet1 Cheatsheet: Leetcode Common Templates & Common Code Problems Interview8 pages
- Solved Questions Competitive ProgrammingNo ratings yetSolved Questions Competitive Programming119 pages
- Top 40 Data Structure Interview Questions and Answers (2021) - InterviewBit100% (3)Top 40 Data Structure Interview Questions and Answers (2021) - InterviewBit31 pages
- 100 Days Preparation Strategy To Crack Product Based Companies50% (2)100 Days Preparation Strategy To Crack Product Based Companies33 pages
- How To Prepare For Your SDE Interview at GoogleNo ratings yetHow To Prepare For Your SDE Interview at Google21 pages
- Object-Oriented Basics - Grokking The Object Oriented Design Interview100% (1)Object-Oriented Basics - Grokking The Object Oriented Design Interview270 pages
- 20+ Coding Patterns To Crack Any Coding InterviewsNo ratings yet20+ Coding Patterns To Crack Any Coding Interviews26 pages
- Modern C++ Programming: Including the recent standards C++11, C++17, C++20, C++23From EverandModern C++ Programming: Including the recent standards C++11, C++17, C++20, C++23No ratings yet
- Tata AIG Motor Policy Schedule 3184 6203702430No ratings yetTata AIG Motor Policy Schedule 3184 62037024304 pages
- Style Me Pretty Weddings by Abby Larson - Excerpt0% (1)Style Me Pretty Weddings by Abby Larson - Excerpt15 pages
- Traducere in Engleza Site Spring Dental Mihaela VelcuNo ratings yetTraducere in Engleza Site Spring Dental Mihaela Velcu11 pages
- CE6315 - Water Quality Parameters - Significance - StandardsNo ratings yetCE6315 - Water Quality Parameters - Significance - Standards28 pages
- CFD Simulations of Horizontal Wellbore CleaningNo ratings yetCFD Simulations of Horizontal Wellbore Cleaning44 pages
- How To Upgrade Oracle From Version 10.2.0.3 and 10.2.0.4 To 11.2.0.1No ratings yetHow To Upgrade Oracle From Version 10.2.0.3 and 10.2.0.4 To 11.2.0.160 pages
- 23 Suburban Tahoe Electrical Body Builder SM en US 2022SEP13No ratings yet23 Suburban Tahoe Electrical Body Builder SM en US 2022SEP131,318 pages
- Complete Data Structures and Algorithms Guide: Resources, Notes, Questions, SolutionsComplete Data Structures and Algorithms Guide: Resources, Notes, Questions, Solutions
- 1 Cheatsheet: Leetcode Common Templates & Common Code Problems Interview1 Cheatsheet: Leetcode Common Templates & Common Code Problems Interview
- Top 40 Data Structure Interview Questions and Answers (2021) - InterviewBitTop 40 Data Structure Interview Questions and Answers (2021) - InterviewBit
- 100 Days Preparation Strategy To Crack Product Based Companies100 Days Preparation Strategy To Crack Product Based Companies
- Object-Oriented Basics - Grokking The Object Oriented Design InterviewObject-Oriented Basics - Grokking The Object Oriented Design Interview
- 20+ Coding Patterns To Crack Any Coding Interviews20+ Coding Patterns To Crack Any Coding Interviews
- Modern C++ Programming: Including the recent standards C++11, C++17, C++20, C++23From EverandModern C++ Programming: Including the recent standards C++11, C++17, C++20, C++23
- Traducere in Engleza Site Spring Dental Mihaela VelcuTraducere in Engleza Site Spring Dental Mihaela Velcu
- CE6315 - Water Quality Parameters - Significance - StandardsCE6315 - Water Quality Parameters - Significance - Standards
- How To Upgrade Oracle From Version 10.2.0.3 and 10.2.0.4 To 11.2.0.1How To Upgrade Oracle From Version 10.2.0.3 and 10.2.0.4 To 11.2.0.1
- 23 Suburban Tahoe Electrical Body Builder SM en US 2022SEP1323 Suburban Tahoe Electrical Body Builder SM en US 2022SEP13