全网最详细解法----leetCode-17--电话号码的字母组合，Java入门你值得拥有

for y in maps[c]:
tmp1.append(x+y)
result = tmp1
return result

Solution3. Python3 使用reduce改写

from functools import reduce

class Solution:
def letterCombinations(self, digits: str) -> List[str]:
if len(digits) == 0:
return []
maps = {‘2’:‘abc’,
‘3’:‘def’,
‘4’:‘ghi’,
‘5’:‘jkl’,
‘6’:‘mno’,
‘7’:‘pqrs’,
‘8’:‘tuv’,
‘9’:‘wxyz’
}
return reduce(lambda acc, digit: [x + y for x in acc for y in maps[digit]], digits, [’’])

leetCode 46. 全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

Solution1. C++

class Solution {
public:
vector<vector> permute(vector& nums) {
vector<vector> result;
permuteHelper(nums, 0, result);
return result;
}
private:
void permuteHelper(vector& nums, int begin, vector<vector>& result) {
int size = nums.size();
if(begin >= size) {
result.push_back(nums);
return;
}
for(int i = begin; i < size; ++i) {
swap(nums[begin], nums[i]);
permuteHelper(nums, begin+1, result);
swap(nums[begin], nums[i]);
}
}
};

Solution2. Python3

class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
if len(nums) == 0:
return [[]]
return [[num] + p
for i, num in enumerate(nums)
for p in self.permute(nums[:i]+nums[i+1:])]

leetCode 79. 单词搜索

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
[‘A’,‘B’,‘C’,‘E’],
[‘S’,‘F’,‘C’,‘S’],
[‘A’,‘D’,‘E’,‘E’]
]

给定 word = “ABCCED”, 返回 true.
给定 word = “SEE”, 返回 true.
给定 word = “ABCB”, 返回 false.

Solution1. C++

class Solution {
public:
bool exist(vector<vector>& board, string word) {
if(word.empty()) {
return true;
}
if(board.empty() || board[0].empty()) {
return false;
}
m = board.size();
n = board[0].size();
for (int i=0; i<m; ++i) {
for (int j=0; j<n; ++j) {
if (searchHelper(board, word, 0, i, j)) {
return true;
}
}
}
return false;
}

private:
int m;
int n;
bool searchHelper(vector<vector>& board, string& word, int cur, int i, int j) {
if(i < 0 || i >= m || j < 0 || j >= n || word[cur] != board[i][j]) {
return false;
}
if(cur == word.length()-1) {
return true;
}
char curChar = word[cur];
board[i][j] = ‘\0’;
if(searchHelper(board, word, cur+1, i-1, j) ||
searchHelper(board, word, cur+1, i+1, j) ||
searchHelper(board, word, cur+1, i, j-1) ||
searchHelper(board, word, cur+1, i, j+1)) {
return true;
}
board[i][j] = curChar;
return false;
}
};

Solution2. Python3

class Solution:
m = 0
n = 0
def exist(self, board: List[List[str]], word: str) -> bool:
if not board:
return False
if not word:
return True
self.m = len(board)
self.n = len(board[0])
for i in range(self.m):
for j in range(self.n):
if self.searchHelper(board, word, 0, i, j):
return True
return False

def searchHelper(self, board, word, cur, i, j):
if i < 0 or i >= self.m or j < 0 or j >= self.n or board[i][j] != word[cur]:
return False
if cur == len(word)-1:
return True
curChar = board[i][j]
board[i][j] = ‘*’
if self.searchHelper(board, word, cur+1, i-1, j) or self.searchHelper(board, word, cur+1, i+1, j) or self.searchHelper(board, word, cur+1, i, j-1) or self.searchHelper(board, word, cur+1, i, j+1):
return True
board[i][j] = curChar
return False

leetCode 131. 分割回文串

给定一个字符串 s，将* s *分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: “aab”
输出:
[
[“aa”,“b”],
[“a”,“a”,“b”]
]

Solution1. C++

class Solution {
public:
vector<vector> partition(string s) {
vector<vector> result;
if(s.empty()) {
return result;
}
vector cur;
partitionHelper(0, s, cur, result);
return result;
}
private:
void partitionHelper(int begin, string& s, vector& curPar, vector<vector>& result) {
if(begin == s.size()) {
result.push_back(curPar);
return;
}
for(int i=begin; i<s.size(); ++i) {
if(isPalindrome(s, begin, i)) {
curPar.push_back(s.substr(begin, i-begin+1));
partitionHelper(i+1, s, curPar, result);
curPar.pop_back();
}
}
}

bool isPalindrome(const string& s, int begin, int end) {
while(begin <= end) {
if(s[begin++] != s[end–]) {
return false;
}
}
return true;
}
};

Solution2. Python3

class Solution:
def partition(self, s: str) -> List[List[str]]:
result = []
curPath = []
self.partitionHelper(s, result, curPath)
return result

def partitionHelper(self, s, result, curPath):
if not s:
result.append(curPath)
return
for i in range(1, len(s)+1):
if self.isPalindrome(s[:i]):
self.partitionHelper(s[i:], result, curPath+[s[:i]])

def isPalindrome(self, s):
return s == s[::-1]

leetCode 212. 单词搜索 II

给定一个二维网格 **board **和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。

示例:

输入:
words = [“oath”,“pea”,“eat”,“rain”] and board =
[
[‘o’,‘a’,‘a’,‘n’],
[‘e’,‘t’,‘a’,‘e’],
[‘i’,‘h’,‘k’,‘r’],
[‘i’,‘f’,‘l’,‘v’]
]

输出: [“eat”,“oath”]

说明:
你可以假设所有输入都由小写字母 a-z 组成。

提示:

• 你需要优化回溯算法以通过更大数据量的测试。你能否早点停止回溯？
• 如果当前单词不存在于所有单词的前缀中，则可以立即停止回溯。

Solution1. C++ [DFS+TrieTree]

class TrieNode {
public:
string value;
TrieNode* children[26];
TrieNode() {
memset(children, 0, sizeof(children));
value = “”;
}
};

class Solution {
public:
vector findWords(vector<vector>& board, vector& words) {
vector result;
TrieNode* root = buildTree(words);
for(int i=0; i<board.size(); ++i) {
for(int j=0; j<board[0].size(); ++j) {
dfs(board, i, j, root, result);
}
}
return result;
}

void dfs(vector<vector>& board, int i, int j, TrieNode* p, vector& res) {
char c = board[i][j];
if(c == ‘#’ || p->children[c-‘a’] == NULL)
return;
p = p->children[c-‘a’];
if(p->value != “”) {
res.push_back(p->value);
p->value = “”;
}
board[i][j] = ‘#’;
if(i > 0)
dfs(board, i-1, j, p, res);
if(j > 0)
dfs(board, i, j-1, p, res);
if(i < board.size()-1)
dfs(board, i+1, j, p, res);
if(j < board[0].size()-1)
dfs(board, i, j+1, p, res);
board[i][j] = c;
}

TrieNode* buildTree(vector& words) {
TrieNode* root = new TrieNode();
for(string word : words) {
TrieNode* cur = root;
for(char c : word) {
int i = c - ‘a’;
if(cur->children[i] == NULL)
cur->children[i] = new TrieNode();
cur = cur->children[i];
}
cur->value = wor

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

d;
}
return root;
}

};

Solution2. Python3

class TrieNode:
def init(self):
self.children = collections.defaultdict(TrieNode)
self.value = None

class Solution:
def buildTree(self, words):
root = TrieNode()
for word in words:
cur = root
for c in word:
cur = cur.children[c]
cur.value = word
return root

def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
result = []
root = self.buildTree(words)
for i in range(len(board)):
for j in range(len(board[0])):
self.dfs(board, i, j, root, result)
return result

def dfs(self, board, i, j, p, result):
c = board[i][j]
if c == ‘#’ or not p.children.get©:
return
p = p.children[c]
if p.value:
result.append(p.value)
p.value = None
board[i][j] = ‘#’
if i > 0:
self.dfs(board, i-1, j, p, result)
if j > 0:
self.dfs(board, i, j-1, p, result)
if i < len(board)-1:
self.dfs(board, i+1, j, p, result)
if j < len(board[0])-1:
self.dfs(board, i, j+1, p, result)
board[i][j] = c

leetCode 301. 删除无效的括号

删除最小数量的无效括号，使得输入的字符串有效，返回所有可能的结果。

说明: 输入可能包含了除 ( 和 ) 以外的字符。

示例 1:

输入: “()())()”
输出: ["()()()", “(())()”]

示例 2:

输入: “(a)())()”
输出: ["(a)()()", “(a())()”]

示例 3:

输入: “)(”
输出: [""]

Solution1. C++

class Solution {
public:
vector removeInvalidParentheses(string s) {
unordered_set result;
int left = 0, right = 0, half = 0;
for(char c : s) {
if(c == ‘(’) {
++left;
}
if(c == ‘)’) {
if(left > 0) {
–left;
}
else {
++right;
}
}
}
string cur = “”;
removeHelper(s, 0, left, right, half, cur, result);
return vector(result.begin(), result.end());
}

private:
void removeHelper(string s, int begin, int left, int right, int half, string cur, unordered_set& result) {
if(begin == s.size()) {
if(left == 0 && right == 0 && half == 0) {
result.insert(cur);
}
return;
}
if(s[begin] != ‘(’ && s[begin] != ‘)’) {
removeHelper(s, begin+1, left, right, half, cur+s[begin], result);
}
else {
if(s[begin] == ‘(’) {
if(left > 0) {
removeHelper(s, begin+1, left-1, right, half, cur, result);
}
removeHelper(s, begin+1, left, right, half+1, cur+s[begin], result);
}
else if(s[begin] == ‘)’) {
if(right > 0) {
removeHelper(s, begin+1, left, right-1, half, cur, result);
}
if(half > 0) {
removeHelper(s, begin+1, left, right, half-1, cur+s[begin], result);
}
}
}
}
};

Solution2. Python3

class Solution:
def removeInvalidParentheses(self, s: str) -> List[str]:
result = []

存储已经检查过的字符串 剪枝

self.visited = set([s])
self.removeHelper(s, self.calcHalf(s), result)
return result

def removeHelper(self, s, half, result):
if half == 0:
result.append(s)
return
for i in range(len(s)):
if s[i] in (’(’, ‘)’):
newS = s[:i] + s[i+1:]
newHalf = self.calcHalf(newS)
if newS not in self.visited and newHalf < half:
self.visited.add(newS)
self.removeHelper(newS, newHalf, result)

计算未配对的括号总数

def calcHalf(self, s):
left, right = 0, 0
for c in s:
if c == ‘(’:
left += 1