leetCode 17. 电话号码的字母组合
给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
示例:
输入:"23"
输出:["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
说明:
尽管上面的答案是按字典序排列的,但是你可以任意选择答案输出的顺序。
Solution1. C++
class Solution {
public:
vector<string> letterCombinations(string digits) {
if(digits.empty()) {
return vector<string>();
}
vector<string> result;
result.push_back("");
int size = digits.size();
vector<string> maps = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
for(int i=0; i<digits.size(); ++i) {
string next = maps[digits[i]-'0'];
vector<string> tmp;
for(string str : result) {
for(int i=0; i<next.size(); ++i) {
tmp.push_back(str + next[i]);
}
}
result.swap(tmp);
}
return result;
}
};
Solution2. Python3
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'
}
result = ['']
for c in digits:
tmp1 = []
for x in result:
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<int>> permute(vector<int>& nums) {
vector<vector<int>> result;
permuteHelper(nums, 0, result);
return result;
}
private:
void permuteHelper(vector<int>& nums, int begin, vector<vector<int>>& 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<char>>& 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<char>>& 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<string>> partition(string s) {
vector<vector<string>> result;
if(s.empty()) {
return result;
}
vector<string> cur;
partitionHelper(0, s, cur, result);
return result;
}
private:
void partitionHelper(int begin, string& s, vector<string>& curPar, vector<vector<string>>& 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<string> findWords(vector<vector<char>>& board, vector<string>& words) {
vector<string> 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<char>>& board, int i, int j, TrieNode* p, vector<string>& 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<string>& 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 = word;
}
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(c):
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<string> removeInvalidParentheses(string s) {
unordered_set<string> 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<string>(result.begin(), result.end());
}
private:
void removeHelper(string s, int begin, int left, int right, int half, string cur, unordered_set<string>& 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
elif c == ')':
if left > 0:
left -= 1
else:
right += 1
return left + right
leetCode 44. 通配符匹配
给定一个字符串 (s) 和一个字符模式 (p) ,实现一个支持 '?' 和 '*' 的通配符匹配。
'?' 可以匹配任何单个字符。
'*' 可以匹配任意字符串(包括空字符串)。
两个字符串完全匹配才算匹配成功。
说明:
s可能为空,且只包含从a-z的小写字母。p可能为空,且只包含从a-z的小写字母,以及字符?和*。
示例 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入:
s = "aa"
p = "*"
输出: true
解释: '*' 可以匹配任意字符串。
示例 3:
输入:
s = "cb"
p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
示例 4:
输入:
s = "adceb"
p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".
示例 5:
输入:
s = "acdcb"
p = "a*c?b"
输入: false
Solution1. C++
Solution2. Java
Solution3. Python3
leetCode 10. 正则表达式匹配
给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符。
'*' 匹配零个或多个前面的元素。
匹配应该覆盖整个字符串 (s) ,而不是部分字符串。
说明:
s可能为空,且只包含从a-z的小写字母。p可能为空,且只包含从a-z的小写字母,以及字符.和*。
示例 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入:
s = "aa"
p = "a*"
输出: true
解释: '*' 代表可匹配零个或多个前面的元素, 即可以匹配 'a' 。因此, 重复 'a' 一次, 字符串可变为 "aa"。
示例 3:
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个('*')任意字符('.')。
示例 4:
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 'c' 可以不被重复, 'a' 可以被重复一次。因此可以匹配字符串 "aab"。
示例 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
Solution1. C++
Solution2. Java
Solution3. Python3
原文作者:超级露
原文链接:https://zhuanlan.zhihu.com/p/60471269
侵删!
1万+



被折叠的 条评论
为什么被折叠?



