Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 996ddbe

Browse files
Merge pull request youngyangyang04#2098 from jianghongcheng/master
修改py
2 parents 60a2d4b + 18a406e commit 996ddbe

19 files changed

+906
-831
lines changed

‎problems/0017.电话号码的字母组合.md‎

Lines changed: 129 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -287,99 +287,154 @@ class Solution {
287287
```
288288

289289
## Python
290-
**回溯**
290+
回溯
291291
```python
292292
class Solution:
293293
def __init__(self):
294-
self.answers: List[str] = []
295-
self.answer: str = ''
296-
self.letter_map = {
297-
'2': 'abc',
298-
'3': 'def',
299-
'4': 'ghi',
300-
'5': 'jkl',
301-
'6': 'mno',
302-
'7': 'pqrs',
303-
'8': 'tuv',
304-
'9': 'wxyz'
305-
}
306-
307-
def letterCombinations(self, digits: str) -> List[str]:
308-
self.answers.clear()
309-
if not digits: return []
294+
self.letterMap = [
295+
"", # 0
296+
"", # 1
297+
"abc", # 2
298+
"def", # 3
299+
"ghi", # 4
300+
"jkl", # 5
301+
"mno", # 6
302+
"pqrs", # 7
303+
"tuv", # 8
304+
"wxyz" # 9
305+
]
306+
self.result = []
307+
self.s = ""
308+
309+
def backtracking(self, digits, index):
310+
if index == len(digits):
311+
self.result.append(self.s)
312+
return
313+
digit = int(digits[index]) # 将索引处的数字转换为整数
314+
letters = self.letterMap[digit] # 获取对应的字符集
315+
for i in range(len(letters)):
316+
self.s += letters[i] # 处理字符
317+
self.backtracking(digits, index + 1) # 递归调用,注意索引加1,处理下一个数字
318+
self.s = self.s[:-1] # 回溯,删除最后添加的字符
319+
320+
def letterCombinations(self, digits):
321+
if len(digits) == 0:
322+
return self.result
310323
self.backtracking(digits, 0)
311-
return self.answers
324+
return self.result
325+
326+
```
327+
回溯精简(版本一)
328+
```python
329+
class Solution:
330+
def __init__(self):
331+
self.letterMap = [
332+
"", # 0
333+
"", # 1
334+
"abc", # 2
335+
"def", # 3
336+
"ghi", # 4
337+
"jkl", # 5
338+
"mno", # 6
339+
"pqrs", # 7
340+
"tuv", # 8
341+
"wxyz" # 9
342+
]
343+
self.result = []
312344

313-
def backtracking(self, digits: str, index: int) -> None:
314-
# 回溯函数没有返回值
315-
# Base Case
316-
if index == len(digits): # 当遍历穷尽后的下一层时
317-
self.answers.append(self.answer)
318-
return
319-
# 单层递归逻辑
320-
letters: str = self.letter_map[digits[index]]
345+
def getCombinations(self, digits, index, s):
346+
if index == len(digits):
347+
self.result.append(s)
348+
return
349+
digit = int(digits[index])
350+
letters = self.letterMap[digit]
321351
for letter in letters:
322-
self.answer += letter # 处理
323-
self.backtracking(digits, index + 1) # 递归至下一层
324-
self.answer = self.answer[:-1] # 回溯
352+
self.getCombinations(digits, index + 1, s + letter)
353+
354+
def letterCombinations(self, digits):
355+
if len(digits) == 0:
356+
return self.result
357+
self.getCombinations(digits, 0, "")
358+
return self.result
359+
325360
```
326-
**回溯简化**
361+
回溯精简(版本二)
327362
```python
328363
class Solution:
329364
def __init__(self):
330-
self.answers: List[str] = []
331-
self.letter_map = {
332-
'2': 'abc',
333-
'3': 'def',
334-
'4': 'ghi',
335-
'5': 'jkl',
336-
'6': 'mno',
337-
'7': 'pqrs',
338-
'8': 'tuv',
339-
'9': 'wxyz'
340-
}
341-
342-
def letterCombinations(self, digits: str) -> List[str]:
343-
self.answers.clear()
344-
if not digits: return []
345-
self.backtracking(digits, 0, '')
346-
return self.answers
365+
self.letterMap = [
366+
"", # 0
367+
"", # 1
368+
"abc", # 2
369+
"def", # 3
370+
"ghi", # 4
371+
"jkl", # 5
372+
"mno", # 6
373+
"pqrs", # 7
374+
"tuv", # 8
375+
"wxyz" # 9
376+
]
347377

348-
def backtracking(self, digits: str, index: int, answer: str) -> None:
349-
# 回溯函数没有返回值
350-
# Base Case
351-
if index == len(digits): # 当遍历穷尽后的下一层时
352-
self.answers.append(answer)
353-
return
354-
# 单层递归逻辑
355-
letters: str = self.letter_map[digits[index]]
378+
def getCombinations(self, digits, index, s, result):
379+
if index == len(digits):
380+
result.append(s)
381+
return
382+
digit = int(digits[index])
383+
letters = self.letterMap[digit]
356384
for letter in letters:
357-
self.backtracking(digits, index + 1, answer + letter) # 递归至下一层 + 回溯
385+
self.getCombinations(digits, index + 1, s + letter, result)
386+
387+
def letterCombinations(self, digits):
388+
result = []
389+
if len(digits) == 0:
390+
return result
391+
self.getCombinations(digits, 0, "", result)
392+
return result
393+
394+
358395
```
359-
**使用itertools**
396+
397+
回溯优化使用列表
360398
```python
361399
class Solution:
362-
def letterCombinations(self, digits: str) -> List[str]:
363-
import itertools
364-
if not digits:
365-
return list()
366-
367-
phoneMap = {
368-
"2": "abc",
369-
"3": "def",
370-
"4": "ghi",
371-
"5": "jkl",
372-
"6": "mno",
373-
"7": "pqrs",
374-
"8": "tuv",
375-
"9": "wxyz",
376-
}
400+
def __init__(self):
401+
self.letterMap = [
402+
"", # 0
403+
"", # 1
404+
"abc", # 2
405+
"def", # 3
406+
"ghi", # 4
407+
"jkl", # 5
408+
"mno", # 6
409+
"pqrs", # 7
410+
"tuv", # 8
411+
"wxyz" # 9
412+
]
413+
414+
def getCombinations(self, digits, index, path, result):
415+
if index == len(digits):
416+
result.append(''.join(path))
417+
return
418+
digit = int(digits[index])
419+
letters = self.letterMap[digit]
420+
for letter in letters:
421+
path.append(letter)
422+
self.getCombinations(digits, index + 1, path, result)
423+
path.pop()
424+
425+
def letterCombinations(self, digits):
426+
result = []
427+
if len(digits) == 0:
428+
return result
429+
self.getCombinations(digits, 0, [], result)
430+
return result
431+
432+
377433

378-
groups = (phoneMap[digit] for digit in digits)
379-
return ["".join(combination) for combination in itertools.product(*groups)]
380434
```
381435

382436

437+
383438
## Go
384439

385440
主要在于递归中传递下一个数字

‎problems/0039.组合总和.md‎

Lines changed: 78 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -273,75 +273,101 @@ class Solution {
273273

274274
## Python
275275

276-
**回溯**
276+
回溯(版本一)
277277

278278
```python
279279
class Solution:
280-
def __init__(self):
281-
self.path = []
282-
self.paths = []
283280

284-
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
285-
'''
286-
因为本题没有组合数量限制,所以只要元素总和大于target就算结束
287-
'''
288-
self.path.clear()
289-
self.paths.clear()
290-
self.backtracking(candidates, target, 0, 0)
291-
return self.paths
292-
293-
def backtracking(self, candidates: List[int], target: int, sum_: int, start_index: int) -> None:
294-
# Base Case
295-
if sum_ == target:
296-
self.paths.append(self.path[:]) # 因为是shallow copy,所以不能直接传入self.path
281+
def backtracking(self, candidates, target, total, startIndex, path, result):
282+
if total > target:
297283
return
298-
if sum_ > target:
284+
if total == target:
285+
result.append(path[:])
299286
return
300287

301-
# 单层递归逻辑
302-
for i in range(start_index, len(candidates)):
303-
sum_ += candidates[i]
304-
self.path.append(candidates[i])
305-
self.backtracking(candidates, target, sum_, i) # 因为无限制重复选取,所以不是i+1
306-
sum_ -= candidates[i] # 回溯
307-
self.path.pop() # 回溯
288+
for i in range(startIndex, len(candidates)):
289+
total += candidates[i]
290+
path.append(candidates[i])
291+
self.backtracking(candidates, target, total, i, path, result) # 不用i+1了,表示可以重复读取当前的数
292+
total -= candidates[i]
293+
path.pop()
294+
295+
def combinationSum(self, candidates, target):
296+
result = []
297+
self.backtracking(candidates, target, 0, 0, [], result)
298+
return result
299+
308300
```
309301

310-
**剪枝回溯**
302+
回溯剪枝(版本一)
311303

312304
```python
313305
class Solution:
314-
def __init__(self):
315-
self.path = []
316-
self.paths = []
317306

307+
def backtracking(self, candidates, target, total, startIndex, path, result):
308+
if total == target:
309+
result.append(path[:])
310+
return
311+
312+
for i in range(startIndex, len(candidates)):
313+
if total + candidates[i] > target:
314+
break
315+
total += candidates[i]
316+
path.append(candidates[i])
317+
self.backtracking(candidates, target, total, i, path, result)
318+
total -= candidates[i]
319+
path.pop()
320+
321+
def combinationSum(self, candidates, target):
322+
result = []
323+
candidates.sort() # 需要排序
324+
self.backtracking(candidates, target, 0, 0, [], result)
325+
return result
326+
327+
```
328+
329+
回溯(版本二)
330+
331+
```python
332+
class Solution:
318333
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
319-
'''
320-
因为本题没有组合数量限制,所以只要元素总和大于target就算结束
321-
'''
322-
self.path.clear()
323-
self.paths.clear()
334+
result =[]
335+
self.backtracking(candidates, target, 0, [], result)
336+
return result
337+
def backtracking(self, candidates, target, startIndex, path, result):
338+
if target == 0:
339+
result.append(path[:])
340+
return
341+
if target < 0:
342+
return
343+
for i in range(startIndex, len(candidates)):
344+
path.append(candidates[i])
345+
self.backtracking(candidates, target - candidates[i], i, path, result)
346+
path.pop()
324347

325-
# 为了剪枝需要提前进行排序
326-
candidates.sort()
327-
self.backtracking(candidates, target, 0, 0)
328-
return self.paths
348+
```
349+
350+
回溯剪枝(版本二)
329351

330-
def backtracking(self, candidates: List[int], target: int, sum_: int, start_index: int) -> None:
331-
# Base Case
332-
if sum_ == target:
333-
self.paths.append(self.path[:]) # 因为是shallow copy,所以不能直接传入self.path
352+
```python
353+
class Solution:
354+
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
355+
result =[]
356+
candidates.sort()
357+
self.backtracking(candidates, target, 0, [], result)
358+
return result
359+
def backtracking(self, candidates, target, startIndex, path, result):
360+
if target == 0:
361+
result.append(path[:])
334362
return
335-
# 单层递归逻辑
336-
# 如果本层 sum + condidates[i] > target,就提前结束遍历,剪枝
337-
for i in range(start_index, len(candidates)):
338-
if sum_ + candidates[i] > target:
339-
return
340-
sum_ += candidates[i]
341-
self.path.append(candidates[i])
342-
self.backtracking(candidates, target, sum_, i) # 因为无限制重复选取,所以不是i-1
343-
sum_ -= candidates[i] # 回溯
344-
self.path.pop() # 回溯
363+
364+
for i in range(startIndex, len(candidates)):
365+
if target - candidates[i] < 0:
366+
break
367+
path.append(candidates[i])
368+
self.backtracking(candidates, target - candidates[i], i, path, result)
369+
path.pop()
370+
345371
```
346372

347373
## Go

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /