(JohnZero)LeetCode笔记
LeetCode笔记
- 1.两数之和
- 2.两数相加
- 3.无重复的最长字符串
- 63.不同路径Ⅱ
- 112.路径总和
- 1392.最长快乐前缀
- 1691.面试题 17.13. 恢复空格
1.两数之和
方法一：暴力法
return new int[] { i, j };
方法二：哈希表
以空间换时间，速度较快
2.两数相加
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode dummyHead = new ListNode(0);
ListNode p = l1, q = l2, curr = dummyHead;
int carry = 0;
while (p != null || q != null) {
int x = (p != null) ? p.val : 0;
int y = (q != null) ? q.val : 0;
int sum = carry + x + y;
carry = sum / 10;
curr.next = new ListNode(sum % 10);
curr = curr.next;
if (p != null) p = p.next;
if (q != null) q = q.next;
}
if (carry > 0) {
curr.next = new ListNode(carry);
}
return dummyHead.next;
}
}
3.无重复的最长字符串
方法一：滑动窗口
C++
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 哈希集合，记录每个字符是否出现过
unordered_set<char> occ;
int n = s.size();
// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
int rk = -1, ans = 0;
// 枚举左指针的位置，初始值隐性地表示为 -1
for (int i = 0; i < n; ++i) {
if (i != 0) {
// 左指针向右移动一格，移除一个字符
occ.erase(s[i - 1]);
}
while (rk + 1 < n && !occ.count(s[rk + 1])) {
// 不断地移动右指针
occ.insert(s[++rk]);
}
// 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = max(ans, rk - i + 1);
}
return ans;
}
};
//试验代码
for (auto it = occ.begin(); it != occ.end(); it++)
cout << *it;
cout << endl;
试验代码插入到[10,11]之间的结果：图a
试验代码插入到[14,15]之间的结果：图b
试验代码插入到[18,19]之间的结果：图c
Java
class Solution {
public int lengthOfLongestSubstring(String s) {
// 哈希集合，记录每个字符是否出现过
Set<Character> occ = new HashSet<Character>();
int n = s.length();
// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
int rk = -1, ans = 0;
for (int i = 0; i < n; ++i) {
if (i != 0) {
// 左指针向右移动一格，移除一个字符
occ.remove(s.charAt(i - 1));
}
while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {
// 不断地移动右指针
occ.add(s.charAt(rk + 1));
++rk;
}
// 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = Math.max(ans, rk - i + 1);
}
return ans;
}
};
63.不同路径Ⅱ
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int n = obstacleGrid.size(), m = obstacleGrid.at(0).size();
vector <int> f(m);
f[0] = (obstacleGrid[0][0] == 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (obstacleGrid[i][j] == 1) {
f[j] = 0;
continue;
}
if (j - 1 >= 0 && obstacleGrid[i][j - 1] == 0) {
f[j] += f[j - 1];
}
}
}
return f.back();
}
};
112.路径总和
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public:
bool hasPathSum(TreeNode* root, int sum) {
if (root == nullptr) {
return false;
}
if (root->left == nullptr && root->right == nullptr) {
return sum == root->val;
}
return hasPathSum(root->left, sum - root->val) ||
hasPathSum(root->right, sum - root->val);
}
};
1392.最长快乐前缀
「快乐前缀」是在原字符串中既是 非空 前缀也是后缀（不包括原字符串自身）的字符串。
给你一个字符串 s，请你返回它的 最长快乐前缀。
如果不存在满足题意的前缀，则返回一个空字符串。
示例 1：
输入：s = "level"
输出："l"
解释：不包括 s 自己，一共有 4 个前缀（“l”, “le”, “lev”, “leve”）和 4 个后缀（“l”, “el”, “vel”, “evel”）。最长的既是前缀也是后缀的字符串是 “l” 。
示例 2：
输入：s = "ababab"
输出："abab"
解释：“abab” 是最长的既是前缀也是后缀的字符串。题目允许前后缀在原字符串中重叠。
示例 3：
输入：s = "leetcodeleet"
输出："leet"
示例 4：
输入：s = "a"
输出：""
提示：
1 <= s.length <= 10^5
s 只含有小写英文字母
方法一：Rabin-Karp 字符串编码
class Solution {
public:
string longestPrefix(string s) {
int n = s.size();
int prefix = 0, suffix = 0;
int base = 31, mod = 1000000007, mul = 1;
int happy = 0;
for (int i = 1; i < n; ++i) {
prefix = ((long long)prefix * base + (s[i - 1] - 97)) % mod;
suffix = (suffix + (long long)(s[n - i] - 97) * mul) % mod;
if (prefix == suffix) {
happy = i;
}
mul = (long long)mul * base % mod;
}
return s.substr(0, happy);
}
};
复杂度分析
时间复杂度：O(N)，其中 N 是字符串 s 的长度。
空间复杂度：O(1)。
方法二：KMP 算法
class Solution {
public:
string longestPrefix(string s) {
int n = s.size();
vector<int> fail(n, -1);
for (int i = 1; i < n; ++i) {
int j = fail[i - 1];
while (j != -1 && s[j + 1] != s[i]) {
j = fail[j];
}
if (s[j + 1] == s[i]) {
fail[i] = j + 1;
}
}
return s.substr(0, fail[n - 1] + 1);
}
};
复杂度分析
时间复杂度：O(N)，其中 N 是字符串 s 的长度。
空间复杂度：O(N)，需要使用到长度为 N 的数组 fail。
1691.面试题 17.13. 恢复空格
哦，不！你不小心把一个长篇文章中的空格、标点都删掉了，并且大写也弄成了小写。像句子"I
reset the computer. It still didn’t boot!“已经变成了"iresetthecomputeritstilldidntboot”。在处理标点符号和大小写之前，你得先把它断成词语。当然了，你有一本厚厚的词典dictionary，不过，有些词没在词典里。假设文章用sentence表示，设计一个算法，把文章断开，要求未识别的字符最少，返回未识别的字符数。
注意：本题相对原题稍作改动，只需返回未识别的字符数
示例：
输入：
dictionary = [“looked”,“just”,“like”,“her”,“brother”]
sentence = “jesslookedjustliketimherbrother”
输出： 7
解释： 断句后为"jess looked just like tim her brother"，共7个未识别字符。
提示：
0 <= len(sentence) <= 1000
dictionary中总字符数不超过 150000。
你可以认为dictionary和sentence中只包含小写字母。
方法一：Trie + 动态规划
class Trie {
public:
Trie* next[26] = { nullptr };
bool isEnd;
Trie() {
isEnd = false;
}
void insert(string s) {
Trie* curPos = this;
for (int i = s.length() - 1; i >= 0; --i) {
int t = s[i] - 'a';
if (curPos->next[t] == nullptr) {
curPos->next[t] = new Trie();
}
curPos = curPos->next[t];
}
curPos->isEnd = true;
}
};
class Solution {
public:
int respace(vector<string>& dictionary, string sentence) {
int n = sentence.length(), inf = 0x3f3f3f3f;
Trie* root = new Trie();
for (auto& word : dictionary) {
root->insert(word);
}
vector<int> dp(n + 1, inf);
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
dp[i] = dp[i - 1] + 1;
Trie* curPos = root;
for (int j = i; j >= 1; --j) {
int t = sentence[j - 1] - 'a';
if (curPos->next[t] == nullptr) {
break;
}
else if (curPos->next[t]->isEnd) {
dp[i] = min(dp[i], dp[j - 1]);
}
if (dp[i] == 0) {
break;
}
curPos = curPos->next[t];
}
}
return dp[n];
}
};
方法二：字符串哈希
较之方法一，有空间复杂度上的优化
class Solution {
public:
using LL = long long;
static constexpr LL P = (1LL << 31) - 1; //P=2147483647是一个质数
static constexpr LL BASE = 41;
LL getHash(const string& s) {
LL hashValue = 0;
for (int i = s.size() - 1; i >= 0; --i) {
hashValue = hashValue * BASE + s[i] - 'a' + 1;
hashValue = hashValue % P;
}
return hashValue;
}
int respace(vector<string>& dictionary, string sentence) {
unordered_set <LL> hashValues;
for (const auto& word : dictionary) {
hashValues.insert(getHash(word));
}
vector <int> f(sentence.size() + 1, sentence.size());
f[0] = 0;
for (int i = 1; i <= sentence.size(); ++i) {
f[i] = f[i - 1] + 1;
LL hashValue = 0;
for (int j = i; j >= 1; --j) {
int t = sentence[j - 1] - 'a' + 1;
hashValue = hashValue * BASE + t;
hashValue = hashValue % P;
if (hashValues.find(hashValue) != hashValues.end()) {
f[i] = min(f[i], f[j - 1]);
}
}
}
return f[sentence.size()];
}
};