Skip to content

S
skill_tree_dailycode

CSDN 技术社区 / skill_tree_dailycode

通知 11
Star 4
Fork 1
S
skill_tree_dailycode
提交 c1efa19b 编写于 作者: ToTensor's avatar ToTensor
浏览文件
操作

增加20题

上级 37497e85
隐藏空白更改
内联 并排
Showing with 2297 addition and 141 deletion
.gitignore
浏览文件 @ c1efa19b
......@@ -9,4 +9,5 @@ helper.py
test.md
data_source/dailycode
test.cpp
test.py
\ No newline at end of file
test.py
test.java
\ No newline at end of file
data/3.dailycode高阶/1.cpp/26.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,79 @@
<p>给定一个仅包含 <code>0</code> 和 <code>1</code> 、大小为 <code>rows x cols</code> 的二维二进制矩阵，找出只包含 <code>1</code> 的最大矩形，并返回其面积。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0085.Maximal%20Rectangle/images/maximal.jpg" style="width: 402px; height: 322px;" /><pre><strong>输入：</strong>matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]<strong><br />输出：</strong>6<strong><br />解释：</strong>最大矩形如上图所示。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>matrix = []<strong><br />输出：</strong>0</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>matrix = [["0"]]<strong><br />输出：</strong>0</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>matrix = [["1"]]<strong><br />输出：</strong>1</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>matrix = [["0","0"]]<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>rows == matrix.length</code></li> <li><code>cols == matrix[0].length</code></li> <li><code>0 <= row, cols <= 200</code></li> <li><code>matrix[i][j]</code> 为 <code>'0'</code> 或 <code>'1'</code></li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
static inline int max(int a, int b)
{
return a > b ? a : b;
}
static int area_calc(int *heights, int size)
{
int *indexes = malloc(size * sizeof(int));
int *lhist = malloc(size * sizeof(int));
int *rhist = malloc(size * sizeof(int));
int i, pos = 0;
for (i = 0; i < size; i++)
{
while (pos > 0 && heights[indexes[pos - 1]] >= heights[i])
{
pos--;
}
lhist[i] = pos == 0 ? -1 : indexes[pos - 1];
indexes[pos++] = i;
}
pos = 0;
for (i = size - 1; i >= 0; i--)
{
_________________________;
}
int max_area = 0;
for (i = 0; i < size; i++)
{
int area = heights[i] * (rhist[i] - lhist[i] - 1);
max_area = max(area, max_area);
}
return max_area;
}
static int maximalRectangle(char **matrix, int matrixRowSize, int matrixColSize)
{
int i, j, max_area = 0;
int *heights = malloc(matrixColSize * sizeof(int));
memset(heights, 0, matrixColSize * sizeof(int));
for (i = 0; i < matrixRowSize; i++)
{
for (j = 0; j < matrixColSize; j++)
{
heights[j] = matrix[i][j] == '1' ? heights[j] + 1 : 0;
}
max_area = max(max_area, area_calc(heights, matrixColSize));
}
return max_area;
}
int main(int argc, char **argv)
{
if (argc < 2)
{
fprintf(stderr, "Usage: ./test row1 row2...\n");
exit(-1);
}
int i, j;
int row_size = argc - 1;
int col_size = strlen(argv[1]);
for (i = 0; i < row_size; i++)
{
printf("%s\n", argv[i + 1]);
}
printf("%d\n", maximalRectangle(argv + 1, argc - 1, strlen(argv[1])));
return 0;
}
```
## template
```cpp
......@@ -83,7 +156,12 @@ int main(int argc, char **argv)
## 答案
```cpp
while (pos > 0 && heights[indexes[pos - 1]] >= heights[i])
{
pos--;
}
rhist[i] = pos == 0 ? size : indexes[pos - 1];
indexes[pos++] = i;
```
## 选项
......@@ -91,17 +169,32 @@ int main(int argc, char **argv)
### A
```cpp
while (pos > 0 && heights[indexes[pos - 1]] >= heights[i])
{
pos--;
}
rhist[i] = pos == 0 ? indexes[pos - 1] : size;
indexes[pos++] = i;
```
### B
```cpp
while (pos > 0 && heights[indexes[pos - 1]] >= heights[i])
{
pos--;
}
rhist[i] = pos == 0 ? size : indexes[pos + 1];
indexes[pos++] = i;
```
### C
```cpp
while (pos > 0 && heights[indexes[pos - 1]] >= heights[i])
{
pos++;
}
rhist[i] = pos == 0 ? size : indexes[pos - 1];
indexes[pos++] = i;
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/27.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,44 @@
<p>给你两个单词 <code>word1</code> 和 <code>word2</code>，请你计算出将 <code>word1</code> 转换成 <code>word2</code><em> </em>所使用的最少操作数 。</p><p>你可以对一个单词进行如下三种操作：</p><ul> <li>插入一个字符</li> <li>删除一个字符</li> <li>替换一个字符</li></ul><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>word1 = "horse", word2 = "ros"<strong><br />输出：</strong>3<strong><br />解释：</strong>horse -> rorse (将 'h' 替换为 'r')rorse -> rose (删除 'r')rose -> ros (删除 'e')</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>word1 = "intention", word2 = "execution"<strong><br />输出：</strong>5<strong><br />解释：</strong>intention -> inention (删除 't')inention -> enention (将 'i' 替换为 'e')enention -> exention (将 'n' 替换为 'x')exention -> exection (将 'n' 替换为 'c')exection -> execution (插入 'u')</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= word1.length, word2.length <= 500</code></li> <li><code>word1</code> 和 <code>word2</code> 由小写英文字母组成</li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
int minDistance(string word1, string word2)
{
int l1 = word1.length();
int l2 = word2.length();
vector<int> dp(l2 + 1);
for (int i = 0; i <= l2; i++)
{
dp[i] = i;
}
int up = 0;
for (int i = 1; i <= l1; i++)
{
int left_up = dp[0];
dp[0] = i;
for (int j = 1; j <= l2; j++)
{
up = dp[j];
_________________________;
else
{
dp[j] = 1 + min(left_up, min(up, dp[j - 1]));
}
left_up = up;
}
}
return dp[l2];
}
};
```
## template
```cpp
......@@ -46,7 +84,10 @@ public:
## 答案
```cpp
if (word1[i - 1] == word2[j - 1])
{
dp[j] = left_up;
}
```
## 选项
......@@ -54,17 +95,26 @@ public:
### A
```cpp
if (word1[i + 1] == word2[j + 1])
{
dp[j] = left_up;
}
```
### B
```cpp
if (word1[i] == word2[j])
{
dp[j] = left_up;
}
```
### C
```cpp
if (word1[i - 1] == word2[j - 1])
{
dp[j] = left_up + 1;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/28.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -64,6 +64,121 @@
</pre>
</div>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void line_fill(char *line, int len, char **words, int *word_lens, int max_size,
int even_spaces, int remain_spaces, int start, int end)
{
int i, j;
char *p = line;
for (i = start; i < end; i++)
{
memcpy(p, words[i], word_lens[i]);
p += word_lens[i];
if (i < end - 1)
{
___________________;
}
}
while (p - line < max_size)
{
*p++ = ' ';
}
*p++ = '\0';
}
static char **fullJustify(char **words, int wordsSize, int maxWidth, int *returnSize)
{
int i, j, k, cap = 100, count = 0;
char **lines = malloc(cap * sizeof(char *));
char *buf = malloc(cap * (maxWidth + 1));
for (i = 0; i < cap; i++)
{
lines[i] = buf + i * (maxWidth + 1);
}
int *word_lens = malloc(wordsSize * sizeof(int));
for (i = 0; i < wordsSize; i++)
{
word_lens[i] = strlen(words[i]);
}
int wc = 0;
int len = 0;
int start = 0;
int chars = 0;
for (i = 0, j = 0; i < wordsSize; i++)
{
if (len + word_lens[i] > maxWidth)
{
int even_spaces = wc == 1 ? 0 : (maxWidth - chars) / (wc - 1);
int remain_spaces = wc == 1 ? 0 : (maxWidth - chars) % (wc - 1);
line_fill(lines[count], len, words, word_lens, maxWidth, even_spaces, remain_spaces, start, i);
count++;
wc = 1;
len = word_lens[i] + 1;
chars = word_lens[i];
start = i;
}
else if (len + word_lens[i] == maxWidth)
{
chars += word_lens[i];
int even_spaces = wc == 0 ? 0 : (maxWidth - chars) / wc;
int remain_spaces = wc == 0 ? 0 : (maxWidth - chars) % wc;
line_fill(lines[count], len, words, word_lens, maxWidth, even_spaces, remain_spaces, start, i + 1);
count++;
wc = 0;
len = 0;
chars = 0;
start = i + 1;
}
else
{
chars += word_lens[i];
len += word_lens[i] + 1;
wc++;
}
}
if (wc > 0)
{
char *p = lines[count];
for (i = start; i < start + wc; i++)
{
memcpy(p, words[i], word_lens[i]);
p += word_lens[i];
if (i < start + wc - 1)
{
*p++ = ' ';
}
}
while (p - lines[count] < maxWidth)
{
*p++ = ' ';
}
*p++ = '\0';
count++;
}
*returnSize = count;
return lines;
}
int main(int argc, char **argv)
{
if (argc <= 2)
{
fprintf(stderr, "Usage: ./test maxsize words...\n");
exit(-1);
}
int i, count;
char **lines = fullJustify(argv + 2, argc - 2, atoi(argv[1]), &count);
for (i = 0; i < count; i++)
{
printf("%s\n", lines[i]);
}
return 0;
}
```
## template
```cpp
......@@ -190,7 +305,15 @@ int main(int argc, char **argv)
## 答案
```cpp
for (j = 0; j < even_spaces; j++)
{
*p++ = ' ';
}
if (remain_spaces > 0)
{
*p++ = ' ';
remain_spaces--;
}
```
## 选项
......@@ -198,17 +321,41 @@ int main(int argc, char **argv)
### A
```cpp
for (j = 0; j < even_spaces; j++)
{
*p++ = ' ';
}
if (remain_spaces > 0)
{
*p++ = ' ';
remain_spaces++;
}
```
### B
```cpp
for (j = 0; j < even_spaces; j++)
{
*p++ = ' ';
}
if (remain_spaces < 0)
{
*p++ = ' ';
remain_spaces++;
}
```
### C
```cpp
for (j = 0; j < even_spaces; j++)
{
*p++ = '\0';
}
if (remain_spaces > 0)
{
*p++ = '\0';
remain_spaces--;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/29.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,43 @@
<p>给你一个只包含 <code>'('</code> 和 <code>')'</code> 的字符串，找出最长有效（格式正确且连续）括号子串的长度。</p><p> </p><div class="original__bRMd"><div><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "(()"<strong><br />输出：</strong>2<strong><br />解释：</strong>最长有效括号子串是 "()"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = ")()())"<strong><br />输出：</strong>4<strong><br />解释：</strong>最长有效括号子串是 "()()"</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = ""<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= s.length <= 3 * 10<sup>4</sup></code></li> <li><code>s[i]</code> 为 <code>'('</code> 或 <code>')'</code></li></ul></div></div>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
int longestValidParentheses(string s)
{
stack<int> stk;
int invalid = -1;
int len = 0, max_len = 0;
for (int i = 0; i < s.length(); i++)
{
if (s[i] == '(')
{
stk.push(i);
}
else
{
if (stk.empty())
{
invalid = i;
}
else
{
stk.pop();
___________________;
}
}
}
return max_len;
}
};
```
## template
```cpp
......@@ -49,7 +86,14 @@ public:
## 答案
```cpp
if (stk.empty())
{
max_len = max(i - invalid, max_len);
}
else
{
max_len = max(i - stk.top(), max_len);
}
```
## 选项
......@@ -57,17 +101,38 @@ public:
### A
```cpp
if (stk.empty())
{
max_len = max(i - invalid, max_len);
}
else
{
max_len = max(stk.top(), max_len);
}
```
### B
```cpp
if (stk.empty())
{
max_len = max(invalid, max_len);
}
else
{
max_len = max(i - stk.top(), max_len);
}
```
### C
```cpp
if (stk.empty())
{
max_len = max(invalid - i, max_len);
}
else
{
max_len = max(i - stk.top(), max_len);
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/30.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,54 @@
<p><strong>n 皇后问题</strong> 研究的是如何将 <code>n</code> 个皇后放置在 <code>n×n</code> 的棋盘上，并且使皇后彼此之间不能相互攻击。</p><p>给你一个整数 <code>n</code> ，返回所有不同的 <strong>n<em> </em>皇后问题</strong> 的解决方案。</p><div class="original__bRMd"><div><p>每一种解法包含一个不同的 <strong>n 皇后问题</strong> 的棋子放置方案，该方案中 <code>'Q'</code> 和 <code>'.'</code> 分别代表了皇后和空位。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" /><pre><strong>输入：</strong>n = 4<strong><br />输出：</strong>[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]<strong><br />解释：</strong>如上图所示，4 皇后问题存在两个不同的解法。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>n = 1<strong><br />输出：</strong>[["Q"]]</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= n <= 9</code></li> <li>皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。</li></ul></div></div>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
vector<vector<string>> solveNQueens(int n)
{
vector<vector<string>> res;
vector<int> stack(n);
vector<string> solution(n, string(n, '.'));
dfs(n, 0, stack, solution, res);
return res;
}
private:
void dfs(int n, int row, vector<int> &stack, vector<string> &solution, vector<vector<string>> &res)
{
if (row == n)
{
res.push_back(solution);
}
else
{
for (int i = 0; i < n; i++)
{
if (row == 0 || !conflict(stack, row, i))
{
__________________;
}
}
}
}
bool conflict(vector<int> &stack, int row, int col)
{
for (int i = 0; i < row; i++)
{
if (col == stack[i] || abs(row - i) == abs(col - stack[i]))
{
return true;
}
}
return false;
}
}
```
## template
```cpp
......@@ -56,7 +104,10 @@ private:
## 答案
```cpp
solution[row][i] = 'Q';
stack[row] = i;
dfs(n, row + 1, stack, solution, res);
solution[row][i] = '.';
```
## 选项
......@@ -64,17 +115,26 @@ private:
### A
```cpp
solution[row][i] = 'Q';
stack[row] = i;
dfs(n, row, stack, solution, res);
solution[row][i] = '.';
```
### B
```cpp
solution[row][i] = '.';
stack[row] = i;
dfs(n, row + 1, stack, solution, res);
solution[row][i] = 'Q';
```
### C
```cpp
solution[row][i] = '.';
stack[row] = i;
dfs(n, row, stack, solution, res);
solution[row][i] = 'Q';
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/31.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -60,6 +60,65 @@
</ul>
</div>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
static bool scramble(char *s1, int low1, int high1, char *s2, int low2, int high2)
{
if (high1 - low1 != high2 - low2)
{
return false;
}
else if (!memcmp(s1 + low1, s2 + low2, high1 - low1 + 1))
{
return true;
}
else
{
int i, c1[128] = {0}, c2[128] = {0};
for (i = low1; i <= high1; i++)
{
c1[s1[i]]++;
}
for (i = low2; i <= high2; i++)
{
c2[s2[i]]++;
}
if (memcmp(c1, c2, 128 * sizeof(int)))
{
return false;
}
else
{
int len = high1 - low1 + 1;
for (i = 1; i < len; i++)
{
_________________________;
}
return false;
}
}
}
static bool isScramble(char *s1, char *s2)
{
return scramble(s1, 0, strlen(s1) - 1, s2, 0, strlen(s2) - 1);
}
int main(int argc, char **argv)
{
if (argc != 3)
{
fprintf(stderr, "Usage: ./test s1 s2\n");
exit(-1);
}
printf("%s\n", isScramble(argv[1], argv[2]) ? "true" : "false");
return 0;
}
```
## template
```cpp
......@@ -131,7 +190,16 @@ int main(int argc, char **argv)
## 答案
```cpp
if (scramble(s1, low1, low1 + i - 1, s2, low2, low2 + i - 1) &&
scramble(s1, low1 + i, high1, s2, low2 + i, high2))
{
return true;
}
if (scramble(s1, low1, low1 + i - 1, s2, high2 - i + 1, high2) &&
scramble(s1, low1 + i, high1, s2, low2, high2 - i))
{
return true;
}
```
## 选项
......@@ -139,17 +207,40 @@ int main(int argc, char **argv)
### A
```cpp
if (scramble(s1, low1, low1 + i - 1, s2, low2, low2 + i - 1) ||
scramble(s1, low1 + i, high1, s2, low2 + i, high2))
{
return true;
}
if (scramble(s1, low1, low1 + i - 1, s2, high2 - i + 1, high2) ||
scramble(s1, low1 + i, high1, s2, low2, high2 - i))
{
return true;
}
```
### B
```cpp
if (scramble(s1, low1, low1 + i - 1, s2, low2, low2 + i - 1)
{
return true;
}
if (scramble(s1, low1 + i, high1, s2, low2, high2 - i))
{
return true;
}
```
### C
```cpp
if (scramble(s1, low1 + i, high1, s2, low2 + i, high2))
{
return true;
}
if (scramble(s1, low1 + i, high1, s2, low2, high2 - i))
{
return true;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/32.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,36 @@
<p>给你一个链表，每 <em>k </em>个节点一组进行翻转，请你返回翻转后的链表。</p><p><em>k </em>是一个正整数，它的值小于或等于链表的长度。</p><p>如果节点总数不是 <em>k </em>的整数倍，那么请将最后剩余的节点保持原有顺序。</p><p><strong>进阶：</strong></p><ul> <li>你可以设计一个只使用常数额外空间的算法来解决此问题吗？</li> <li><strong>你不能只是单纯的改变节点内部的值</strong>，而是需要实际进行节点交换。</li></ul><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0025.Reverse%20Nodes%20in%20k-Group/images/reverse_ex1.jpg" style="width: 542px; height: 222px;" /><pre><strong>输入：</strong>head = [1,2,3,4,5], k = 2<strong><br />输出：</strong>[2,1,4,3,5]</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0025.Reverse%20Nodes%20in%20k-Group/images/reverse_ex2.jpg" style="width: 542px; height: 222px;" /><pre><strong>输入：</strong>head = [1,2,3,4,5], k = 3<strong><br />输出：</strong>[3,2,1,4,5]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>head = [1,2,3,4,5], k = 1<strong><br />输出：</strong>[1,2,3,4,5]</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>head = [1], k = 1<strong><br />输出：</strong>[1]</pre><ul></ul><p><strong>提示：</strong></p><ul> <li>列表中节点的数量在范围 <code>sz</code> 内</li> <li><code>1 <= sz <= 5000</code></li> <li><code>0 <= Node.val <= 1000</code></li> <li><code>1 <= k <= sz</code></li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
class Solution
{
public:
ListNode *reverseGroup(ListNode *head, int k)
{
int len = 0;
struct ListNode dummy, *prev = &dummy;
dummy.next = head;
for (; head != nullptr; head = head->next)
{
____________________;
}
return dummy.next;
}
};
```
## template
```cpp
......@@ -47,7 +77,19 @@ public:
## 答案
```cpp
if (++len % k == 0)
{
struct ListNode *p = prev->next;
while (prev->next != head)
{
struct ListNode *q = p->next;
p->next = q->next;
q->next = prev->next;
prev->next = q;
}
prev = p;
head = p;
}
```
## 选项
......@@ -55,17 +97,53 @@ public:
### A
```cpp
if (len % k == 0)
{
struct ListNode *p = prev->next;
while (prev->next != head)
{
struct ListNode *q = p->next;
p->next = q->next;
q->next = prev->next;
prev->next = q;
}
prev = p;
head = p;
}
```
### B
```cpp
if (++len % k == 0)
{
struct ListNode *p = prev->next;
while (prev->next != head)
{
struct ListNode *q = p->next;
prev->next = q;
q->next = prev->next;
p->next = q->next;
}
prev = p;
head = p;
}
```
### C
```cpp
if (++len % k == 0)
{
struct ListNode *p = prev->next;
while (prev->next != head)
{
struct ListNode *q = p->next;
prev->next = q;
p->next = q->next;
q->next = prev->next;
}
prev = p;
head = p;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/33.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,52 @@
<p><strong>有效数字</strong>（按顺序）可以分成以下几个部分：</p><ol> <li>一个 <strong>小数</strong> 或者 <strong>整数</strong></li> <li>（可选）一个 <code>'e'</code> 或 <code>'E'</code> ，后面跟着一个 <strong>整数</strong></li></ol><p><strong>小数</strong>（按顺序）可以分成以下几个部分：</p><ol> <li>（可选）一个符号字符（<code>'+'</code> 或 <code>'-'</code>）</li> <li>下述格式之一： <ol> <li>至少一位数字，后面跟着一个点 <code>'.'</code></li> <li>至少一位数字，后面跟着一个点 <code>'.'</code> ，后面再跟着至少一位数字</li> <li>一个点 <code>'.'</code> ，后面跟着至少一位数字</li> </ol> </li></ol><p><strong>整数</strong>（按顺序）可以分成以下几个部分：</p><ol> <li>（可选）一个符号字符（<code>'+'</code> 或 <code>'-'</code>）</li> <li>至少一位数字</li></ol><p>部分有效数字列举如下：</p><ul> <li><code>["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]</code></li></ul><p>部分无效数字列举如下：</p><ul> <li><code>["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]</code></li></ul><p>给你一个字符串 <code>s</code> ，如果 <code>s</code> 是一个 <strong>有效数字</strong> ，请返回 <code>true</code> 。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "0"<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = "e"<strong><br />输出：</strong>false</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = "."<strong><br />输出：</strong>false</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>s = ".1"<strong><br />输出：</strong>true</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= s.length <= 20</code></li> <li><code>s</code> 仅含英文字母（大写和小写），数字（<code>0-9</code>），加号 <code>'+'</code> ，减号 <code>'-'</code> ，或者点 <code>'.'</code> 。</li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h>
static bool isNumber(const char *s)
{
while (*s == ' ')
++s;
bool if_find_num = false;
if (*s == '-' || *s == '+')
++s;
while (isdigit(*s))
{
if_find_num = true;
++s;
}
if (*s == '.')
++s;
while (isdigit(*s))
{
if_find_num = true;
++s;
}
if (if_find_num == true && *s == 'e')
{
___________________;
}
while (*s == ' ')
++s;
return *s == '\0' && if_find_num == true;
}
int main(int argc, char **argv)
{
if (argc != 2)
{
fprintf(stderr, "Usage: ./test number\n");
exit(-1);
}
printf("%s\n", isNumber(argv[1]) ? "true" : "false");
return 0;
}
```
## template
```cpp
......@@ -59,7 +105,15 @@ int main(int argc, char **argv)
## 答案
```cpp
++s;
if (*s == '+' || *s == '-')
++s;
if_find_num = false;
while (isdigit(*s))
{
if_find_num = true;
++s;
}
```
## 选项
......@@ -67,17 +121,39 @@ int main(int argc, char **argv)
### A
```cpp
if (*s == '+' || *s == '-')
++s;
if_find_num = false;
while (isdigit(*s))
{
if_find_num = true;
++s;
}
```
### B
```cpp
if (*s == '+' || *s == '-')
++s;
if_find_num = true;
while (isdigit(*s))
{
if_find_num = false;
++s;
}
```
### C
```cpp
++s;
if (*s == '+' || *s == '-')
++s;
if_find_num = true;
while (isdigit(*s))
{
if_find_num = false;
++s;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/34.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -9,6 +9,45 @@
<p><strong>示例 2：</strong></p>
<pre><strong>输入： s =</strong> &quot;wordgoodgoodgoodbestword&quot;,<strong> words = </strong>[&quot;word&quot;,&quot;good&quot;,&quot;best&quot;,&quot;word&quot;]<strong><br />输出：</strong>[]</pre>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
vector<int> findSubstring(string s, vector<string> &words)
{
vector<int> res;
if (s.empty() || words.empty())
{
return res;
}
unordered_map<string, int> ht;
for (const auto &w : words)
{
ht[w]++;
}
int len = words[0].length();
for (int i = 0, j = 0; i < s.length() - words.size() * len + 1; i++)
{
unordered_map<string, int> counting;
for (j = 0; j < words.size(); j++)
{
string word = s.substr(i + j * len, len);
______________________;
}
if (j == words.size())
{
res.push_back(i);
}
}
return res;
}
};
```
## template
```cpp
......@@ -54,7 +93,10 @@ public:
## 答案
```cpp
if (++counting[word] > ht[word])
{
break;
}
```
## 选项
......@@ -62,17 +104,26 @@ public:
### A
```cpp
if (++counting[word] < ht[word])
{
break;
}
```
### B
```cpp
if (++counting[word] <= ht[word])
{
continue;
}
```
### C
```cpp
if (++counting[word] <= ht[word])
{
break;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/35.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,46 @@
<p>给定两个大小分别为 <code>m</code> 和 <code>n</code> 的正序（从小到大）数组 <code>nums1</code> 和 <code>nums2</code>。请你找出并返回这两个正序数组的 <strong>中位数</strong> 。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums1 = [1,3], nums2 = [2]<strong><br />输出：</strong>2.00000<strong><br />解释：</strong>合并数组 = [1,2,3] ，中位数 2</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums1 = [1,2], nums2 = [3,4]<strong><br />输出：</strong>2.50000<strong><br />解释：</strong>合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums1 = [0,0], nums2 = [0,0]<strong><br />输出：</strong>0.00000</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>nums1 = [], nums2 = [1]<strong><br />输出：</strong>1.00000</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>nums1 = [2], nums2 = []<strong><br />输出：</strong>2.00000</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>nums1.length == m</code></li> <li><code>nums2.length == n</code></li> <li><code>0 <= m <= 1000</code></li> <li><code>0 <= n <= 1000</code></li> <li><code>1 <= m + n <= 2000</code></li> <li><code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code></li></ul><p> </p><p><strong>进阶：</strong>你能设计一个时间复杂度为 <code>O(log (m+n))</code> 的算法解决此问题吗？</p>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
class Solution
{
public:
double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2)
{
int nums1Size = nums1.size();
int nums2Size = nums2.size();
int na = nums1Size + nums2Size;
int *ns = (int *)malloc(4 * na);
int i = 0, j = 0, d = 0;
int m = na / 2 + 1;
while (d < m)
{
int n;
if (i < nums1Size && j < nums2Size)
{
________________________;
}
else if (i < nums1Size)
{
n = nums1[i++];
}
else if (j < nums2Size)
{
n = nums2[j++];
}
ns[d++] = n;
}
if (na % 2)
{
return ns[d - 1];
}
return (ns[d - 1] + ns[d - 2]) / 2.0;
}
};
```
## template
```cpp
......@@ -45,7 +85,7 @@ public:
## 答案
```cpp
n = (nums1[i] < nums2[j]) ? nums1[i++] : nums2[j++];
```
## 选项
......@@ -53,17 +93,17 @@ public:
### A
```cpp
n = (nums1[i] < nums2[j]) ? nums1[j++] : nums2[i++];
```
### B
```cpp
n = (nums1[i] > nums2[j]) ? nums1[i++] : nums2[j++];
```
### C
```cpp
n = (nums1[i] >= nums2[j]) ? nums1[i++] : nums2[j++];
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/36.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,45 @@
<p>给你一个字符串 <code>s</code> 、一个字符串 <code>t</code> 。返回 <code>s</code> 中涵盖 <code>t</code> 所有字符的最小子串。如果 <code>s</code> 中不存在涵盖 <code>t</code> 所有字符的子串，则返回空字符串 <code>""</code> 。</p><p><strong>注意：</strong>如果 <code>s</code> 中存在这样的子串，我们保证它是唯一的答案。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "ADOBECODEBANC", t = "ABC"<strong><br />输出：</strong>"BANC"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = "a", t = "a"<strong><br />输出：</strong>"a"</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= s.length, t.length <= 10<sup>5</sup></code></li> <li><code>s</code> 和 <code>t</code> 由英文字母组成</li></ul><p> </p><strong>进阶：</strong>你能设计一个在 <code>o(n)</code> 时间内解决此问题的算法吗？
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
string minWindow(string s, string t)
{
vector<int> count(128);
for (char c : t)
{
count[c]++;
}
int l = 0, r = 0;
int need_to_meet = t.length();
int start, min_len = INT_MAX;
while (r < s.length())
{
if (--count[s[r++]] >= 0)
{
need_to_meet--;
}
while (need_to_meet == 0)
{
if (r - l < min_len)
{
start = l;
min_len = r - l;
}
___________________;
}
}
return min_len == INT_MAX ? "" : s.substr(start, min_len);
}
};
```
## template
```cpp
......@@ -47,7 +86,10 @@ public:
## 答案
```cpp
if (++count[s[l++]] > 0)
{
need_to_meet++;
}
```
## 选项
......@@ -55,17 +97,26 @@ public:
### A
```cpp
if (count[s[l++]] > 0)
{
need_to_meet++;
}
```
### B
```cpp
if (count[s[l++]] >= 0)
{
need_to_meet++;
}
```
### C
```cpp
if (++count[s[l++]++] > 0)
{
need_to_meet++;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/37.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,47 @@
<p>给你一个链表数组，每个链表都已经按升序排列。</p><p>请你将所有链表合并到一个升序链表中，返回合并后的链表。</p><p>&nbsp;</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>lists = [[1,4,5],[1,3,4],[2,6]]<strong><br />输出：</strong>[1,1,2,3,4,4,5,6]<strong><br />解释：</strong>链表数组如下：[ 1-&gt;4-&gt;5, 1-&gt;3-&gt;4, 2-&gt;6]将它们合并到一个有序链表中得到。1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4-&gt;5-&gt;6</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>lists = []<strong><br />输出：</strong>[]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>lists = [[]]<strong><br />输出：</strong>[]</pre><p>&nbsp;</p><p><strong>提示：</strong></p><ul> <li><code>k == lists.length</code></li> <li><code>0 &lt;= k &lt;= 10^4</code></li> <li><code>0 &lt;= lists[i].length &lt;= 500</code></li> <li><code>-10^4 &lt;= lists[i][j] &lt;= 10^4</code></li> <li><code>lists[i]</code> 按 <strong>升序</strong> 排列</li> <li><code>lists[i].length</code> 的总和不超过 <code>10^4</code></li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
class Solution
{
public:
ListNode *mergeKLists(vector<ListNode *> &lists)
{
auto cmp = [](struct ListNode *n1, struct ListNode *n2)
{
return n1->val > n2->val;
} priority_queue<struct ListNode *, vector<struct ListNode *>, decltype(cmp)>
queue(cmp);
for (int i = 0; i < lists.size(); i++)
{
if (lists[i] != nullptr)
{
queue.push(lists[i]);
}
}
struct ListNode dummy, *p = &dummy;
;
while (!queue.empty())
{
_________________;
}
return dummy.next;
}
};
```
## template
```cpp
......@@ -53,7 +94,14 @@ public:
## 答案
```cpp
ListNode *node = queue.top();
queue.pop();
p->next = node;
p = node;
if (node->next != nullptr)
{
queue.push(node->next);
}
```
## 选项
......@@ -61,17 +109,38 @@ public:
### A
```cpp
ListNode *node = queue.top();
queue.pop();
p->next = node;
p = node;
if (node->next != nullptr)
{
queue.pop(node->next);
}
```
### B
```cpp
ListNode *node = queue.top();
queue.pop();
p = node;
p->next = node;
if (node->next != nullptr)
{
queue.push(node->next);
}
```
### C
```cpp
ListNode *node = queue.top();
queue.pop();
p = node;
p->next = node;
if (node->next != nullptr)
{
queue.pop(node->next);
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/38.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,51 @@
<p>给出集合 <code>[1,2,3,...,n]</code>，其所有元素共有 <code>n!</code> 种排列。</p><p>按大小顺序列出所有排列情况，并一一标记，当 <code>n = 3</code> 时, 所有排列如下：</p><ol> <li><code>"123"</code></li> <li><code>"132"</code></li> <li><code>"213"</code></li> <li><code>"231"</code></li> <li><code>"312"</code></li> <li><code>"321"</code></li></ol><p>给定 <code>n</code> 和 <code>k</code>，返回第 <code>k</code> 个排列。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>n = 3, k = 3<strong><br />输出：</strong>"213"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>n = 4, k = 9<strong><br />输出：</strong>"2314"</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>n = 3, k = 1<strong><br />输出：</strong>"123"</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= n <= 9</code></li> <li><code>1 <= k <= n!</code></li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char *getPermutation(int n, int k)
{
int i;
char *result = malloc(n + 1);
bool *used = malloc(n * sizeof(bool));
memset(used, false, n * sizeof(bool));
int total = 1;
for (i = 1; i <= n; i++)
{
total *= i;
}
k = k - 1;
for (i = 0; i < n; i++)
{
total /= (n - i);
int gid = k / total;
k %= total;
int x = -1;
int count = 0;
____________________;
used[x] = true;
result[i] = x + 1 + '0';
}
result[n] = '\0';
return result;
}
int main(int argc, char **argv)
{
if (argc != 3)
{
fprintf(stderr, "Usage: ./test n, k\n");
exit(-1);
}
printf("%s\n", getPermutation(atoi(argv[1]), atoi(argv[2])));
return 0;
}
```
## template
```cpp
......@@ -57,7 +102,14 @@ int main(int argc, char **argv)
## 答案
```cpp
while (count <= gid)
{
x = (x + 1) % n;
if (!used[x])
{
count++;
}
}
```
## 选项
......@@ -65,17 +117,38 @@ int main(int argc, char **argv)
### A
```cpp
while (count <= gid)
{
x = (x + 1) % n;
if (used[x])
{
count++;
}
}
```
### B
```cpp
while (count < gid)
{
x = (x + 1) % n;
if (used[x])
{
count++;
}
}
```
### C
```cpp
while (count <= gid)
{
x = x % n;
if (used[x])
{
count++;
}
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/39.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,52 @@
<p>给定一个字符串&nbsp;(<code>s</code>) 和一个字符模式&nbsp;(<code>p</code>) ，实现一个支持&nbsp;<code>&#39;?&#39;</code>&nbsp;和&nbsp;<code>&#39;*&#39;</code>&nbsp;的通配符匹配。</p><pre>&#39;?&#39; 可以匹配任何单个字符。&#39;*&#39; 可以匹配任意字符串（包括空字符串）。</pre><p>两个字符串<strong>完全匹配</strong>才算匹配成功。</p><p><strong>说明:</strong></p><ul> <li><code>s</code>&nbsp;可能为空，且只包含从&nbsp;<code>a-z</code>&nbsp;的小写字母。</li> <li><code>p</code>&nbsp;可能为空，且只包含从&nbsp;<code>a-z</code>&nbsp;的小写字母，以及字符&nbsp;<code>?</code>&nbsp;和&nbsp;<code>*</code>。</li></ul><p><strong>示例&nbsp;1:</strong></p><pre><strong>输入:</strong>s = &quot;aa&quot;p = &quot;a&quot;<strong><br />输出:</strong> false<strong><br />解释:</strong> &quot;a&quot; 无法匹配 &quot;aa&quot; 整个字符串。</pre><p><strong>示例&nbsp;2:</strong></p><pre><strong>输入:</strong>s = &quot;aa&quot;p = &quot;*&quot;<strong><br />输出:</strong> true<strong><br />解释:</strong>&nbsp;&#39;*&#39; 可以匹配任意字符串。</pre><p><strong>示例&nbsp;3:</strong></p><pre><strong>输入:</strong>s = &quot;cb&quot;p = &quot;?a&quot;<strong><br />输出:</strong> false<strong><br />解释:</strong>&nbsp;&#39;?&#39; 可以匹配 &#39;c&#39;, 但第二个 &#39;a&#39; 无法匹配 &#39;b&#39;。</pre><p><strong>示例&nbsp;4:</strong></p><pre><strong>输入:</strong>s = &quot;adceb&quot;p = &quot;*a*b&quot;<strong><br />输出:</strong> true<strong><br />解释:</strong>&nbsp;第一个 &#39;*&#39; 可以匹配空字符串, 第二个 &#39;*&#39; 可以匹配字符串 &quot;dce&quot;.</pre><p><strong>示例&nbsp;5:</strong></p><pre><strong>输入:</strong>s = &quot;acdcb&quot;p = &quot;a*c?b&quot;<strong><br />输出:</strong> false</pre>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
static bool isMatch(char *s, char *p)
{
char *last_s = NULL;
char *last_p = NULL;
while (*s != '\0')
{
if (*p == '*')
{
if (*++p == '\0')
{
return true;
}
last_s = s;
last_p = p;
}
_____________________;
else
{
return false;
}
}
while (*p == '*')
{
p++;
}
return *p == '\0';
}
int main(int argc, char **argv)
{
if (argc != 3)
{
fprintf(stderr, "Usage: ./test string pattern\n");
exit(-1);
}
printf("%s\n", isMatch(argv[1], argv[2]) ? "true" : "false");
return 0;
}
```
## template
```cpp
......@@ -60,7 +106,16 @@ int main(int argc, char **argv)
## 答案
```cpp
else if (*p == '?' || *s == *p)
{
s++;
p++;
}
else if (last_s != NULL)
{
p = last_p;
s = ++last_s;
}
```
## 选项
......@@ -68,17 +123,34 @@ int main(int argc, char **argv)
### A
```cpp
else if (last_s != NULL)
{
p = last_p;
s = ++last_s;
}
```
### B
```cpp
else if (*p == '?' || *s == *p)
{
s++;
p++;
}
```
### C
```cpp
else if (*p == '?' && *s == *p)
{
s++;
p++;
}
else if (last_s != NULL)
{
p = last_p;
s = ++last_s;
}
```
\ No newline at end of file
data/3.dailycode高阶/1.cpp/40.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,25 @@
<p>给你一个字符串 <code>s</code> 和一个字符规律 <code>p</code>，请你来实现一个支持 <code>'.'</code> 和 <code>'*'</code> 的正则表达式匹配。</p><ul> <li><code>'.'</code> 匹配任意单个字符</li> <li><code>'*'</code> 匹配零个或多个前面的那一个元素</li></ul><p>所谓匹配，是要涵盖 <strong>整个 </strong>字符串 <code>s</code>的，而不是部分字符串。</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "aa" p = "a"<strong><br />输出：</strong>false<strong><br />解释：</strong>"a" 无法匹配 "aa" 整个字符串。</pre><p><strong>示例 2:</strong></p><pre><strong>输入：</strong>s = "aa" p = "a*"<strong><br />输出：</strong>true<strong><br />解释：</strong>因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = "ab" p = ".*"<strong><br />输出：</strong>true<strong><br />解释：</strong>".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>s = "aab" p = "c*a*b"<strong><br />输出：</strong>true<strong><br />解释：</strong>因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>s = "mississippi" p = "mis*is*p*."<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= s.length <= 20</code></li> <li><code>0 <= p.length <= 30</code></li> <li><code>s</code> 可能为空，且只包含从 <code>a-z</code> 的小写字母。</li> <li><code>p</code> 可能为空，且只包含从 <code>a-z</code> 的小写字母，以及字符 <code>.</code> 和 <code>*</code>。</li> <li>保证每次出现字符 <code>*</code> 时，前面都匹配到有效的字符</li></ul>
以下程序实现了这一功能，请你填补空白处的内容：
```cpp
bool isMatch(char *s, char *p)
{
if (!p || p[0] == NULL)
return (!s || s[0] == NULL);
bool head_match = (s && s[0] && (s[0] == p[0] || p[0] == '.'));
if (p[1] && p[1] == '*')
{
_____________________;
}
else
{
return head_match && isMatch(s + 1, p + 1);
}
}
```
## template
```cpp
......@@ -24,7 +43,7 @@ bool isMatch(char *s, char *p)
## 答案
```cpp
return (head_match && isMatch(s + 1, p)) || isMatch(s, p + 2);
```
## 选项
......@@ -32,17 +51,17 @@ bool isMatch(char *s, char *p)
### A
```cpp
return (head_match && isMatch(s + 1, p)) && isMatch(s, p + 2);
```
### B
```cpp
return (head_match || isMatch(s + 1, p)) || isMatch(s, p + 2);
```
### C
```cpp
return (head_match || isMatch(s + 1, p)) && isMatch(s, p + 2);
```
\ No newline at end of file
data/3.dailycode高阶/2.java/1.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -52,6 +52,67 @@
</div>
</div>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
boolean row[][] = new boolean[9][9];
boolean col[][] = new boolean[9][9];
boolean cell[][][] = new boolean[3][3][9];
public void solveSudoku(char[][] board) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (board[i][j] != '.') {
int t = board[i][j] - '1';
row[i][t] = col[j][t] = cell[i / 3][j / 3][t] = true;
}
}
}
dfs(board, 0, 0);
}
public boolean dfs(char[][] board, int x, int y) {
if (y == 9) {
x++;
y = 0;
}
if (x == 9)
return true;
____________________;
for (int num = 0; num < 9; num++) {
if (!row[x][num] && !col[y][num] && !cell[x / 3][y / 3][num]) {
board[x][y] = (char) (num + '1');
row[x][num] = col[y][num] = cell[x / 3][y / 3][num] = true;
if (dfs(board, x, y + 1))
return true;
board[x][y] = '.';
row[x][num] = col[y][num] = cell[x / 3][y / 3][num] = false;
}
}
return false;
}
}
```
## template
```java
......@@ -116,7 +177,8 @@ class Solution {
## 答案
```java
if (board[x][y] != '.')
return dfs(board, x, y + 1);
```
## 选项
......@@ -124,17 +186,20 @@ class Solution {
### A
```java
if (board[x][y] != '.')
return dfs(board, x, y);
```
### B
```java
if (board[x][y] == '.')
return dfs(board, x, y);
```
### C
```java
if (board[x][y] == '.')
return dfs(board, x, y + 1);
```
\ No newline at end of file
data/3.dailycode高阶/2.java/10.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,59 @@
<p><strong>n 皇后问题</strong> 研究的是如何将 <code>n</code> 个皇后放置在 <code>n×n</code> 的棋盘上，并且使皇后彼此之间不能相互攻击。</p><p>给你一个整数 <code>n</code> ，返回所有不同的 <strong>n<em> </em>皇后问题</strong> 的解决方案。</p><div class="original__bRMd"><div><p>每一种解法包含一个不同的 <strong>n 皇后问题</strong> 的棋子放置方案，该方案中 <code>'Q'</code> 和 <code>'.'</code> 分别代表了皇后和空位。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" /><pre><strong>输入：</strong>n = 4<strong><br />输出：</strong>[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]<strong><br />解释：</strong>如上图所示，4 皇后问题存在两个不同的解法。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>n = 1<strong><br />输出：</strong>[["Q"]]</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= n <= 9</code></li> <li>皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。</li></ul></div></div>
以下程序实现了这一功能，请你填补空白处内容：
```java
import java.util.List;
import java.util.ArrayList;
public class Solution {
public List<List<String>> solveNQueens(int n) {
List<List<String>> res = new ArrayList<List<String>>();
int[] queenList = new int[n];
placeQueen(queenList, 0, n, res);
return res;
}
private void placeQueen(int[] queenList, int row, int n, List<List<String>> res) {
if (row == n) {
ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < n; i++) {
String str = "";
for (int col = 0; col < n; col++) {
if (queenList[i] == col) {
str += "Q";
} else {
str += ".";
}
}
list.add(str);
}
res.add(list);
}
for (int col = 0; col < n; col++) {
if (isValid(queenList, row, col)) {
queenList[row] = col;
________________________;
}
}
}
private boolean isValid(int[] queenList, int row, int col) {
for (int i = 0; i < row; i++) {
int pos = queenList[i];
if (pos == col) {
return false;
}
if (pos + row - i == col) {
return false;
}
if (pos - row + i == col) {
return false;
}
}
return true;
}
}
```
## template
```java
......@@ -58,7 +111,7 @@ public class Solution {
## 答案
```java
placeQueen(queenList, row + 1, n, res);
```
## 选项
......@@ -66,17 +119,17 @@ public class Solution {
### A
```java
placeQueen(queenList, row, n, res);
```
### B
```java
placeQueen(queenList, row + 1, n + 1, res);
```
### C
```java
placeQueen(queenList, row, n + 1, res);
```
\ No newline at end of file
data/3.dailycode高阶/2.java/11.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -60,6 +60,44 @@
</ul>
</div>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public boolean isScramble(String s1, String s2) {
if (s1.length() == 0 && s2.length() == 0)
return true;
if (s1.length() != s2.length())
return false;
return dfs(s1.toCharArray(), s2.toCharArray(), 0, 0, s1.length());
}
private boolean dfs(char[] s1, char[] s2, int start1, int start2, int len) {
if (len == 1) {
return s1[start1] == s2[start2];
}
if (!equals(s1, s2, start1, start2, len)) {
return false;
}
for (int i = 1; i < len; i++) {
____________________;
}
return false;
}
public boolean equals(char[] s1, char[] s2, int start1, int start2, int len) {
int[] charArr = new int[26];
for (int i = 0; i < len; i++) {
charArr[s1[start1 + i] - 'a']++;
charArr[s2[start2 + i] - 'a']--;
}
for (int item : charArr) {
if (item != 0)
return false;
}
return true;
}
}
```
## template
```java
......@@ -104,7 +142,10 @@ class Solution {
## 答案
```java
if (dfs(s1, s2, start1, start2, i) && dfs(s1, s2, start1 + i, start2 + i, len - i))
return true;
if (dfs(s1, s2, start1, start2 + len - i, i) && dfs(s1, s2, start1 + i, start2, len - i))
return true;
```
## 选项
......@@ -112,17 +153,26 @@ class Solution {
### A
```java
if (dfs(s1, s2, start1, start2, i))
return true;
if (dfs(s1, s2, start1, start2 + len - i, i))
return true;
```
### B
```java
if (dfs(s1, s2, start1 + i, start2 + i, len - i))
return true;
if (dfs(s1, s2, start1 + i, start2, len - i))
return true;
```
### C
```java
if (dfs(s1, s2, start1 + i, start2 + i, len - i))
return true;
if (dfs(s1, s2, start1, start2 + len - i, i))
return true;
```
\ No newline at end of file
data/3.dailycode高阶/2.java/12.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,60 @@
<p>给你一个链表，每 <em>k </em>个节点一组进行翻转，请你返回翻转后的链表。</p><p><em>k </em>是一个正整数，它的值小于或等于链表的长度。</p><p>如果节点总数不是 <em>k </em>的整数倍，那么请将最后剩余的节点保持原有顺序。</p><p><strong>进阶：</strong></p><ul> <li>你可以设计一个只使用常数额外空间的算法来解决此问题吗？</li> <li><strong>你不能只是单纯的改变节点内部的值</strong>，而是需要实际进行节点交换。</li></ul><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0025.Reverse%20Nodes%20in%20k-Group/images/reverse_ex1.jpg" style="width: 542px; height: 222px;" /><pre><strong>输入：</strong>head = [1,2,3,4,5], k = 2<strong><br />输出：</strong>[2,1,4,3,5]</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0025.Reverse%20Nodes%20in%20k-Group/images/reverse_ex2.jpg" style="width: 542px; height: 222px;" /><pre><strong>输入：</strong>head = [1,2,3,4,5], k = 3<strong><br />输出：</strong>[3,2,1,4,5]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>head = [1,2,3,4,5], k = 1<strong><br />输出：</strong>[1,2,3,4,5]</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>head = [1], k = 1<strong><br />输出：</strong>[1]</pre><ul></ul><p><strong>提示：</strong></p><ul> <li>列表中节点的数量在范围 <code>sz</code> 内</li> <li><code>1 <= sz <= 5000</code></li> <li><code>0 <= Node.val <= 1000</code></li> <li><code>1 <= k <= sz</code></li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
public class ListNode {
int val;
ListNode next;
ListNode() {
}
ListNode(int val) {
this.val = val;
}
ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
if (head == null) {
return null;
}
ListNode a = head, b = head;
for (int i = 0; i < k; i++) {
if (b == null) {
return a;
}
b = b.next;
}
ListNode newHead = reverse(a, b);
a.next = reverseKGroup(b, k);
return newHead;
}
public ListNode reverse(ListNode a, ListNode b) {
ListNode pre, cur, nxt;
pre = null;
cur = a;
nxt = a;
while (nxt != b) {
__________________;
}
return pre;
}
}
```
## template
```java
......@@ -62,7 +116,10 @@ class Solution {
## 答案
```java
nxt = cur.next;
cur.next = pre;
pre = cur;
cur = nxt;
```
## 选项
......@@ -70,17 +127,26 @@ class Solution {
### A
```java
cur.next = pre;
nxt = cur.next;
pre = cur;
cur = nxt;
```
### B
```java
cur.next = pre;
nxt = cur.next;
cur = nxt;
pre = cur;
```
### C
```java
nxt = cur.next;
cur.next = pre;
cur = nxt;
pre = cur;
```
\ No newline at end of file
data/3.dailycode高阶/2.java/13.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,79 @@
<p><strong>有效数字</strong>（按顺序）可以分成以下几个部分：</p><ol> <li>一个 <strong>小数</strong> 或者 <strong>整数</strong></li> <li>（可选）一个 <code>'e'</code> 或 <code>'E'</code> ，后面跟着一个 <strong>整数</strong></li></ol><p><strong>小数</strong>（按顺序）可以分成以下几个部分：</p><ol> <li>（可选）一个符号字符（<code>'+'</code> 或 <code>'-'</code>）</li> <li>下述格式之一： <ol> <li>至少一位数字，后面跟着一个点 <code>'.'</code></li> <li>至少一位数字，后面跟着一个点 <code>'.'</code> ，后面再跟着至少一位数字</li> <li>一个点 <code>'.'</code> ，后面跟着至少一位数字</li> </ol> </li></ol><p><strong>整数</strong>（按顺序）可以分成以下几个部分：</p><ol> <li>（可选）一个符号字符（<code>'+'</code> 或 <code>'-'</code>）</li> <li>至少一位数字</li></ol><p>部分有效数字列举如下：</p><ul> <li><code>["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]</code></li></ul><p>部分无效数字列举如下：</p><ul> <li><code>["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]</code></li></ul><p>给你一个字符串 <code>s</code> ，如果 <code>s</code> 是一个 <strong>有效数字</strong> ，请返回 <code>true</code> 。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "0"<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = "e"<strong><br />输出：</strong>false</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = "."<strong><br />输出：</strong>false</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>s = ".1"<strong><br />输出：</strong>true</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= s.length <= 20</code></li> <li><code>s</code> 仅含英文字母（大写和小写），数字（<code>0-9</code>），加号 <code>'+'</code> ，减号 <code>'-'</code> ，或者点 <code>'.'</code> 。</li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
char[] chars;
boolean point = false;
boolean exponent = false;
public boolean isNumber(String s) {
s = s.trim();
int length = s.length();
if (length == 0) {
return false;
}
chars = s.toCharArray();
String[] ss = s.split("e");
if (ss.length == 0) {
return false;
}
if (ss[0].length() == 0)
return false;
if (ss[0].length() < length)
exponent = true;
if (ss[0].length() == length - 1) {
return false;
}
String[] pre = ss[0].split("\\.");
if (pre.length == 0) {
return false;
}
if (pre[0].length() < ss[0].length())
point = true;
boolean result = pre(0, pre[0].length());
result = result && middle(pre[0].length() + 1, ss[0].length());
if (exponent) {
result = result && is(ss[0].length() + 1, length);
}
return result;
}
____________________________;
public boolean middle(int i, int length) {
if (i >= length && point) {
if (chars[i - 2] >= '0' && chars[i - 2] <= '9') {
return true;
}
return false;
}
for (; i < length; i++) {
if (chars[i] < '0' || chars[i] > '9') {
return false;
}
}
return true;
}
public boolean is(int i, int length) {
if (i == 1) {
return false;
}
if (chars[i] == '+' || chars[i] == '-') {
i++;
}
if (i == length) {
return false;
}
for (; i < length; i++) {
if (chars[i] < '0' || chars[i] > '9') {
return false;
}
}
return true;
}
}
```
## template
```java
......@@ -94,7 +167,23 @@ class Solution {
## 答案
```java
public boolean pre(int i, int length) {
if (i >= length) {
return true;
}
if (chars[i] == '+' || chars[i] == '-') {
i++;
}
if (i == length && !point) {
return false;
}
for (; i < length; i++) {
if (chars[i] < '0' || chars[i] > '9') {
return false;
}
}
return true;
}
```
## 选项
......@@ -102,17 +191,65 @@ class Solution {
### A
```java
public boolean pre(int i, int length) {
if (i >= length) {
return true;
}
if (chars[i] == '+' || chars[i] == '-') {
i++;
}
if (i == length && !point) {
return false;
}
for (; i < length; i++) {
if (chars[i] < '0' || chars[i] > '9') {
return true;
}
}
return false;
}
```
### B
```java
public boolean pre(int i, int length) {
if (i >= length) {
return false;
}
if (chars[i] == '+' || chars[i] == '-') {
i++;
}
if (i == length && !point) {
return true;
}
for (; i < length; i++) {
if (chars[i] < '0' || chars[i] > '9') {
return true;
}
}
return false;
}
```
### C
```java
public boolean pre(int i, int length) {
if (i >= length) {
return false;
}
if (chars[i] == '+' || chars[i] == '-') {
i++;
}
if (i == length && !point) {
return true;
}
for (; i < length; i++) {
if (chars[i] < '0' || chars[i] > '9') {
return false;
}
}
return true;
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/14.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -9,6 +9,47 @@
<p><strong>示例 2：</strong></p>
<pre><strong>输入： s =</strong> &quot;wordgoodgoodgoodbestword&quot;,<strong> words = </strong>[&quot;word&quot;,&quot;good&quot;,&quot;best&quot;,&quot;word&quot;]<strong><br />输出：</strong>[]</pre>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> res = new ArrayList<>();
if (s == null || s.length() == 0 || words == null || words.length == 0)
return res;
HashMap<String, Integer> map = new HashMap<>();
int one_word = words[0].length();
int word_num = words.length;
int all_len = one_word * word_num;
for (String word : words) {
map.put(word, map.getOrDefault(word, 0) + 1);
}
for (int i = 0; i < one_word; i++) {
int left = i, right = i, count = 0;
HashMap<String, Integer> tmp_map = new HashMap<>();
while (right + one_word <= s.length()) {
String w = s.substring(right, right + one_word);
right += one_word;
if (!map.containsKey(w)) {
count = 0;
left = right;
tmp_map.clear();
} else {
tmp_map.put(w, tmp_map.getOrDefault(w, 0) + 1);
count++;
while (tmp_map.getOrDefault(w, 0) > map.getOrDefault(w, 0)) {
______________________;
}
if (count == word_num)
res.add(left);
}
}
}
return res;
}
}
```
## template
```java
......@@ -56,7 +97,10 @@ class Solution {
## 答案
```java
String t_w = s.substring(left, left + one_word);
count--;
tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0) - 1);
left += one_word;
```
## 选项
......@@ -64,17 +108,26 @@ class Solution {
### A
```java
String t_w = s.substring(left, left + one_word);
count--;
tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0));
left += one_word;
```
### B
```java
String t_w = s.substring(left, left + one_word);
count--;
tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0) + 1);
left += one_word;
```
### C
```java
String t_w = s.substring(left, left - one_word);
count--;
tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0) + 1);
left += one_word;
```
\ No newline at end of file
data/3.dailycode高阶/2.java/15.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,30 @@
<p>给定两个大小分别为 <code>m</code> 和 <code>n</code> 的正序（从小到大）数组 <code>nums1</code> 和 <code>nums2</code>。请你找出并返回这两个正序数组的 <strong>中位数</strong> 。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums1 = [1,3], nums2 = [2]<strong><br />输出：</strong>2.00000<strong><br />解释：</strong>合并数组 = [1,2,3] ，中位数 2</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums1 = [1,2], nums2 = [3,4]<strong><br />输出：</strong>2.50000<strong><br />解释：</strong>合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums1 = [0,0], nums2 = [0,0]<strong><br />输出：</strong>0.00000</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>nums1 = [], nums2 = [1]<strong><br />输出：</strong>1.00000</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>nums1 = [2], nums2 = []<strong><br />输出：</strong>2.00000</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>nums1.length == m</code></li> <li><code>nums2.length == n</code></li> <li><code>0 <= m <= 1000</code></li> <li><code>0 <= n <= 1000</code></li> <li><code>1 <= m + n <= 2000</code></li> <li><code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code></li></ul><p> </p><p><strong>进阶：</strong>你能设计一个时间复杂度为 <code>O(log (m+n))</code> 的算法解决此问题吗？</p>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int nums1Size = nums1.length;
int nums2Size = nums2.length;
int na = nums1Size + nums2Size;
int[] ns = new int[4 * na];
int i = 0, j = 0, d = 0;
int m = na / 2 + 1;
while (d < m) {
int n = 0;
_________________;
ns[d++] = n;
}
if (na % 2 == 1) {
return ns[d - 1];
}
return (ns[d - 1] + ns[d - 2]) / 2.0;
}
}
```
## template
```java
......@@ -35,7 +59,13 @@ class Solution {
## 答案
```java
if (i < nums1Size && j < nums2Size) {
n = (nums1[i] < nums2[j]) ? nums1[i++] : nums2[j++];
} else if (i < nums1Size) {
n = nums1[i++];
} else if (j < nums2Size) {
n = nums2[j++];
}
```
## 选项
......@@ -43,17 +73,35 @@ class Solution {
### A
```java
if (i < nums1Size && j < nums2Size) {
n = (nums1[j] < nums2[i]) ? nums2[i++] : nums1[j++];
} else if (i < nums1Size) {
n = nums1[j++];
} else if (j < nums2Size) {
n = nums2[i++];
}
```
### B
```java
if (i < nums1Size && j < nums2Size) {
n = (nums1[j] > nums2[i]) ? nums2[i++] : nums1[j++];
} else if (i > nums1Size) {
n = nums1[j++];
} else if (j > nums2Size) {
n = nums2[i++];
}
```
### C
```java
if (i < nums1Size && j > nums2Size) {
n = (nums1[j] < nums2[i]) ? nums2[i++] : nums1[j++];
} else if (i < nums1Size) {
n = nums1[j++];
} else if (j < nums2Size) {
n = nums2[i++];
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/16.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,43 @@
<p>给你一个字符串 <code>s</code> 、一个字符串 <code>t</code> 。返回 <code>s</code> 中涵盖 <code>t</code> 所有字符的最小子串。如果 <code>s</code> 中不存在涵盖 <code>t</code> 所有字符的子串，则返回空字符串 <code>""</code> 。</p><p><strong>注意：</strong>如果 <code>s</code> 中存在这样的子串，我们保证它是唯一的答案。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "ADOBECODEBANC", t = "ABC"<strong><br />输出：</strong>"BANC"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = "a", t = "a"<strong><br />输出：</strong>"a"</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= s.length, t.length <= 10<sup>5</sup></code></li> <li><code>s</code> 和 <code>t</code> 由英文字母组成</li></ul><p> </p><strong>进阶：</strong>你能设计一个在 <code>o(n)</code> 时间内解决此问题的算法吗？
以下程序实现了这一功能，请你填补空白处内容：
```java
public class Min_Win_Sub {
public String minWindow(String s, String t) {
int[] ta = new int[128];
int[] sa = new int[128];
int min = Integer.MAX_VALUE;
String minwin = "";
for (int i = 0; i < t.length(); i++) {
ta[t.charAt(i)]++;
}
int count = 0;
int end = 0;
int start = 0;
while (end < s.length()) {
if (ta[s.charAt(end)] != 0) {
if (sa[s.charAt(end)] < ta[s.charAt(end)]) {
count++;
}
sa[s.charAt(end)]++;
}
if (count == t.length()) {
_________________;
if (end - start + 1 < min) {
minwin = s.substring(start, end + 1);
min = end - start + 1;
}
}
end++;
}
return minwin;
}
}
```
## template
```java
......@@ -47,7 +84,12 @@ public class Min_Win_Sub {
## 答案
```java
while (ta[s.charAt(start)] == 0 || sa[s.charAt(start)] > ta[s.charAt(start)]) {
if (sa[s.charAt(start)] > ta[s.charAt(start)]) {
sa[s.charAt(start)]--;
}
start++;
}
```
## 选项
......@@ -55,17 +97,32 @@ public class Min_Win_Sub {
### A
```java
while (ta[s.charAt(start)] == 0 || sa[s.charAt(start)] > ta[s.charAt(start)]) {
if (sa[s.charAt(start)] < ta[s.charAt(start)]) {
sa[s.charAt(start)]--;
}
start++;
}
```
### B
```java
while (ta[s.charAt(start)] == 0 || sa[s.charAt(start)] > ta[s.charAt(start)]) {
if (sa[s.charAt(start)] <= ta[s.charAt(start)]) {
sa[s.charAt(start)]--;
}
start++;
}
```
### C
```java
while (ta[s.charAt(start)] == 0 || sa[s.charAt(start)] >= ta[s.charAt(start)]) {
if (sa[s.charAt(start)] <= ta[s.charAt(start)]) {
sa[s.charAt(start)]--;
}
start++;
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/17.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,71 @@
<p>给你一个链表数组，每个链表都已经按升序排列。</p><p>请你将所有链表合并到一个升序链表中，返回合并后的链表。</p><p>&nbsp;</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>lists = [[1,4,5],[1,3,4],[2,6]]<strong><br />输出：</strong>[1,1,2,3,4,4,5,6]<strong><br />解释：</strong>链表数组如下：[ 1-&gt;4-&gt;5, 1-&gt;3-&gt;4, 2-&gt;6]将它们合并到一个有序链表中得到。1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4-&gt;5-&gt;6</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>lists = []<strong><br />输出：</strong>[]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>lists = [[]]<strong><br />输出：</strong>[]</pre><p>&nbsp;</p><p><strong>提示：</strong></p><ul> <li><code>k == lists.length</code></li> <li><code>0 &lt;= k &lt;= 10^4</code></li> <li><code>0 &lt;= lists[i].length &lt;= 500</code></li> <li><code>-10^4 &lt;= lists[i][j] &lt;= 10^4</code></li> <li><code>lists[i]</code> 按 <strong>升序</strong> 排列</li> <li><code>lists[i].length</code> 的总和不超过 <code>10^4</code></li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
public class ListNode {
int val;
ListNode next;
ListNode() {
}
ListNode(int val) {
this.val = val;
}
ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
if (lists.length == 0)
return null;
return merge(lists, 0, lists.length - 1);
}
public ListNode merge(ListNode[] lists, int low, int high) {
if (high - low == 0)
return lists[low];
else if (high - low == 1)
return mergeTwoLists(lists[low], lists[high]);
else {
int mid = (low + high) / 2;
_____________________________;
return mergeTwoLists(tmp1, tmp2);
}
}
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode head = new ListNode();
ListNode p = head;
while (l1 != null && l2 != null) {
if (l1.val > l2.val) {
p.next = l2;
l2 = l2.next;
p = p.next;
} else {
p.next = l1;
l1 = l1.next;
p = p.next;
}
}
if (l1 != null)
p.next = l1;
if (l2 != null)
p.next = l2;
return head.next;
}
}
```
## template
```java
......@@ -71,7 +136,8 @@ class Solution {
## 答案
```java
ListNode tmp1 = merge(lists, low, mid);
ListNode tmp2 = merge(lists, mid + 1, high);
```
## 选项
......@@ -79,17 +145,20 @@ class Solution {
### A
```java
ListNode tmp1 = merge(lists, low, mid);
ListNode tmp2 = merge(lists, mid, high);
```
### B
```java
ListNode tmp1 = merge(lists, low, mid + 1);
ListNode tmp2 = merge(lists, mid + 1, high);
```
### C
```java
ListNode tmp1 = merge(lists, low, mid + 1);
ListNode tmp2 = merge(lists, mid - 1, high);
```
\ No newline at end of file
data/3.dailycode高阶/2.java/18.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,28 @@
<p>给出集合 <code>[1,2,3,...,n]</code>，其所有元素共有 <code>n!</code> 种排列。</p><p>按大小顺序列出所有排列情况，并一一标记，当 <code>n = 3</code> 时, 所有排列如下：</p><ol> <li><code>"123"</code></li> <li><code>"132"</code></li> <li><code>"213"</code></li> <li><code>"231"</code></li> <li><code>"312"</code></li> <li><code>"321"</code></li></ol><p>给定 <code>n</code> 和 <code>k</code>，返回第 <code>k</code> 个排列。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>n = 3, k = 3<strong><br />输出：</strong>"213"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>n = 4, k = 9<strong><br />输出：</strong>"2314"</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>n = 3, k = 1<strong><br />输出：</strong>"123"</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>1 <= n <= 9</code></li> <li><code>1 <= k <= n!</code></li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public String getPermutation(int n, int k) {
StringBuilder sb = new StringBuilder();
List<Integer> candidates = new ArrayList<>();
int[] factorials = new int[n + 1];
factorials[0] = 1;
int fact = 1;
for (int i = 1; i <= n; ++i) {
candidates.add(i);
fact *= i;
factorials[i] = fact;
}
k -= 1;
____________________;
return sb.toString();
}
}
```
## template
```java
......@@ -31,7 +53,11 @@ class Solution {
## 答案
```java
for (int i = n - 1; i >= 0; --i) {
int index = k / factorials[i];
sb.append(candidates.remove(index));
k -= index * factorials[i];
}
```
## 选项
......@@ -39,17 +65,29 @@ class Solution {
### A
```java
for (int i = n - 1; i >= 0; --i) {
int index = k / factorials[i];
sb.append(candidates.remove(index));
k = index * factorials[i];
}
```
### B
```java
for (int i = n - 1; i >= 0; --i) {
int index = k / factorials[i];
sb.append(candidates.remove(index));
k += index * factorials[i];
}
```
### C
```java
for (int i = n; i >= 0; --i) {
int index = k / factorials[i - 1];
sb.append(candidates.remove(index));
k -= index * factorials[i];
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/19.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,39 @@
<p>给定一个字符串&nbsp;(<code>s</code>) 和一个字符模式&nbsp;(<code>p</code>) ，实现一个支持&nbsp;<code>&#39;?&#39;</code>&nbsp;和&nbsp;<code>&#39;*&#39;</code>&nbsp;的通配符匹配。</p><pre>&#39;?&#39; 可以匹配任何单个字符。&#39;*&#39; 可以匹配任意字符串（包括空字符串）。</pre><p>两个字符串<strong>完全匹配</strong>才算匹配成功。</p><p><strong>说明:</strong></p><ul> <li><code>s</code>&nbsp;可能为空，且只包含从&nbsp;<code>a-z</code>&nbsp;的小写字母。</li> <li><code>p</code>&nbsp;可能为空，且只包含从&nbsp;<code>a-z</code>&nbsp;的小写字母，以及字符&nbsp;<code>?</code>&nbsp;和&nbsp;<code>*</code>。</li></ul><p><strong>示例&nbsp;1:</strong></p><pre><strong>输入:</strong>s = &quot;aa&quot;p = &quot;a&quot;<strong><br />输出:</strong> false<strong><br />解释:</strong> &quot;a&quot; 无法匹配 &quot;aa&quot; 整个字符串。</pre><p><strong>示例&nbsp;2:</strong></p><pre><strong>输入:</strong>s = &quot;aa&quot;p = &quot;*&quot;<strong><br />输出:</strong> true<strong><br />解释:</strong>&nbsp;&#39;*&#39; 可以匹配任意字符串。</pre><p><strong>示例&nbsp;3:</strong></p><pre><strong>输入:</strong>s = &quot;cb&quot;p = &quot;?a&quot;<strong><br />输出:</strong> false<strong><br />解释:</strong>&nbsp;&#39;?&#39; 可以匹配 &#39;c&#39;, 但第二个 &#39;a&#39; 无法匹配 &#39;b&#39;。</pre><p><strong>示例&nbsp;4:</strong></p><pre><strong>输入:</strong>s = &quot;adceb&quot;p = &quot;*a*b&quot;<strong><br />输出:</strong> true<strong><br />解释:</strong>&nbsp;第一个 &#39;*&#39; 可以匹配空字符串, 第二个 &#39;*&#39; 可以匹配字符串 &quot;dce&quot;.</pre><p><strong>示例&nbsp;5:</strong></p><pre><strong>输入:</strong>s = &quot;acdcb&quot;p = &quot;a*c?b&quot;<strong><br />输出:</strong> false</pre>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public boolean isMatch(String s, String p) {
boolean[][] value = new boolean[p.length() + 1][s.length() + 1];
value[0][0] = true;
for (int i = 1; i <= s.length(); i++) {
value[0][i] = false;
}
for (int i = 1; i <= p.length(); i++) {
if (p.charAt(i - 1) == '*') {
value[i][0] = value[i - 1][0];
for (int j = 1; j <= s.length(); j++) {
value[i][j] = (value[i][j - 1] || value[i - 1][j]);
}
} else if (p.charAt(i - 1) == '?') {
value[i][0] = false;
for (int j = 1; j <= s.length(); j++) {
value[i][j] = value[i - 1][j - 1];
}
} else {
value[i][0] = false;
for (int j = 1; j <= s.length(); j++) {
____________________;
}
}
}
return value[p.length()][s.length()];
}
}
```
## template
```java
......@@ -38,7 +71,7 @@ class Solution {
## 答案
```java
value[i][j] = s.charAt(j - 1) == p.charAt(i - 1) && value[i - 1][j - 1];
```
## 选项
......@@ -46,17 +79,17 @@ class Solution {
### A
```java
value[i][j] = s.charAt(j - 1) == p.charAt(i - 1) || value[i - 1][j - 1];
```
### B
```java
value[i][j] = s.charAt(j - 1) == p.charAt(i) && value[i - 1][j];
```
### C
```java
value[i][j] = s.charAt(j - 1) == p.charAt(i - 1) && value[i][j - 1];
```
\ No newline at end of file
data/3.dailycode高阶/2.java/2.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,37 @@
<p>给定 <em>n</em> 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。</p><p> </p><p><strong>示例 1：</strong></p><p><img src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0042.Trapping%20Rain%20Water/images/rainwatertrap.png" style="height: 161px; width: 412px;" /></p><pre><strong>输入：</strong>height = [0,1,0,2,1,0,1,3,2,1,2,1]<strong><br />输出：</strong>6<strong><br />解释：</strong>上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 </pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>height = [4,2,0,3,2,5]<strong><br />输出：</strong>9</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>n == height.length</code></li> <li><code>0 <= n <= 3 * 10<sup>4</sup></code></li> <li><code>0 <= height[i] <= 10<sup>5</sup></code></li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public int trap(int[] height) {
if (height == null)
return 0;
int len = height.length;
if (len == 0)
return 0;
int res = 0;
int[] left_max = new int[len];
int[] right_max = new int[len];
left_max[0] = height[0];
for (int i = 1; i < len; i++) {
left_max[i] = Math.max(height[i], left_max[i - 1]);
}
right_max[len - 1] = height[len - 1];
____________________;
for (int i = 1; i < len - 1; i++) {
res += Math.min(left_max[i], right_max[i]) - height[i];
}
return res;
}
}
```
## template
```java
......@@ -38,7 +69,9 @@ class Solution {
## 答案
```java
for (int i = len - 2; i >= 0; i--) {
right_max[i] = Math.max(height[i], right_max[i + 1]);
}
```
## 选项
......@@ -46,17 +79,23 @@ class Solution {
### A
```java
for (int i = len - 2; i >= 0; i--) {
right_max[i] = Math.max(height[i], right_max[i]);
}
```
### B
```java
for (int i = len; i >= 0; i--) {
right_max[i] = Math.max(height[i], right_max[i]);
}
```
### C
```java
for (int i = len; i >= 0; i--) {
right_max[i] = Math.max(height[i], right_max[i + 1]);
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/20.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,19 @@
<p>给你一个字符串 <code>s</code> 和一个字符规律 <code>p</code>，请你来实现一个支持 <code>'.'</code> 和 <code>'*'</code> 的正则表达式匹配。</p><ul> <li><code>'.'</code> 匹配任意单个字符</li> <li><code>'*'</code> 匹配零个或多个前面的那一个元素</li></ul><p>所谓匹配，是要涵盖 <strong>整个 </strong>字符串 <code>s</code>的，而不是部分字符串。</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "aa" p = "a"<strong><br />输出：</strong>false<strong><br />解释：</strong>"a" 无法匹配 "aa" 整个字符串。</pre><p><strong>示例 2:</strong></p><pre><strong>输入：</strong>s = "aa" p = "a*"<strong><br />输出：</strong>true<strong><br />解释：</strong>因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = "ab" p = ".*"<strong><br />输出：</strong>true<strong><br />解释：</strong>".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>s = "aab" p = "c*a*b"<strong><br />输出：</strong>true<strong><br />解释：</strong>因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>s = "mississippi" p = "mis*is*p*."<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= s.length <= 20</code></li> <li><code>0 <= p.length <= 30</code></li> <li><code>s</code> 可能为空，且只包含从 <code>a-z</code> 的小写字母。</li> <li><code>p</code> 可能为空，且只包含从 <code>a-z</code> 的小写字母，以及字符 <code>.</code> 和 <code>*</code>。</li> <li>保证每次出现字符 <code>*</code> 时，前面都匹配到有效的字符</li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public boolean isMatch(String s, String p) {
if (p.length() == 0)
return s.length() == 0;
boolean head_match = s.length() > 0 && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.');
________________;
}
}
```
## template
```java
......@@ -22,7 +35,11 @@ class Solution {
## 答案
```java
if (p.length() > 1 && p.charAt(1) == '*') {
return (head_match && isMatch(s.substring(1), p)) || isMatch(s, p.substring(2));
} else {
return head_match && isMatch(s.substring(1), p.substring(1));
}
```
## 选项
......@@ -30,17 +47,29 @@ class Solution {
### A
```java
if (p.length() > 1 && p.charAt(1) == '*') {
return (head_match && isMatch(s.substring(1), p)) || isMatch(s, p.substring(2));
} else {
return head_match && isMatch(s.substring(1), p.substring(2));
}
```
### B
```java
if (p.length() > 1 && p.charAt(1) == '*') {
return (head_match && isMatch(s.substring(1), p)) || isMatch(s, p.substring(2));
} else {
return isMatch(s.substring(1), p.substring(2));
}
```
### C
```java
if (p.length() > 1 && p.charAt(1) == '*') {
return isMatch(s.substring(1), p)) || isMatch(s, p.substring(2);
} else {
return isMatch(s.substring(1), p.substring(2));
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/3.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,34 @@
<p>给定 <em>n</em> 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。</p><p>求在该柱状图中，能够勾勒出来的矩形的最大面积。</p><p>&nbsp;</p><p><img src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0084.Largest%20Rectangle%20in%20Histogram/images/histogram.png"></p><p><small>以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为&nbsp;<code>[2,1,5,6,2,3]</code>。</small></p><p>&nbsp;</p><p><img src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0084.Largest%20Rectangle%20in%20Histogram/images/histogram_area.png"></p><p><small>图中阴影部分为所能勾勒出的最大矩形面积，其面积为&nbsp;<code>10</code>&nbsp;个单位。</small></p><p>&nbsp;</p><p><strong>示例:</strong></p><pre><strong>输入:</strong> [2,1,5,6,2,3]<strong><br />输出:</strong> 10</pre>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public int largestRectangleArea(int[] heights) {
int length = heights.length;
if (length == 0) {
return 0;
}
int maxSize = 0;
for (int i = 0; i < length; i++) {
int nowHeight = heights[i];
int nowWidth = 0;
for (int j = i; j < length; j++) {
___________________;
nowWidth++;
if (maxSize < nowHeight * nowWidth) {
maxSize = nowHeight * nowWidth;
}
}
}
return maxSize;
}
}
```
## template
```java
......@@ -35,7 +63,9 @@ class Solution {
## 答案
```java
if (heights[j] < nowHeight) {
nowHeight = heights[j];
}
```
## 选项
......@@ -43,17 +73,23 @@ class Solution {
### A
```java
if (heights[j] > nowHeight) {
nowHeight = heights[j];
}
```
### B
```java
if (heights[j] >= nowHeight) {
nowHeight = heights[j] + 1;
}
```
### C
```java
if (heights[j] < nowHeight) {
nowHeight = heights[j] + 1;
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/4.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,39 @@
<p>给你一个未排序的整数数组 <code>nums</code> ，请你找出其中没有出现的最小的正整数。</p><p> </p><p><strong>进阶：</strong>你可以实现时间复杂度为 <code>O(n)</code> 并且只使用常数级别额外空间的解决方案吗？</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums = [1,2,0]<strong><br />输出：</strong>3</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums = [3,4,-1,1]<strong><br />输出：</strong>2</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums = [7,8,9,11,12]<strong><br />输出：</strong>1</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= nums.length <= 300</code></li> <li><code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code></li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public int firstMissingPositive(int[] nums) {
int n = nums.length;
int contains = 0;
for (int i = 0; i < n; i++) {
if (nums[i] == 1) {
contains++;
break;
}
}
if (contains == 0) {
return 1;
}
for (int i = 0; i < n; i++) {
_________________;
}
for (int i = 0; i < n; i++) {
int a = Math.abs(nums[i]);
nums[a - 1] = -Math.abs(nums[a - 1]);
}
for (int i = 0; i < n; i++) {
if (nums[i] > 0) {
return i + 1;
}
}
return n + 1;
}
}
```
## template
```java
......@@ -40,7 +73,9 @@ class Solution {
## 答案
```java
if ((nums[i] <= 0) || (nums[i] > n)) {
nums[i] = 1;
}
```
## 选项
......@@ -48,17 +83,23 @@ class Solution {
### A
```java
if (nums[i] <= 0) {
nums[i] = 1;
}
```
### B
```java
if ((nums[i] <= 0) || (nums[i] > n)) {
nums[i] = 0;
}
```
### C
```java
if (nums[i] > n) {
nums[i] = 1;
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/5.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -35,6 +35,34 @@
</div>
</div>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
private boolean col[];
private boolean dia1[];
private boolean dia2[];
public int totalNQueens(int n) {
col = new boolean[n];
dia1 = new boolean[2 * n - 1];
dia2 = new boolean[2 * n - 1];
return putQueen(n, 0);
}
private int putQueen(int n, int index) {
int res = 0;
if (index == n) {
return 1;
}
for (int i = 0; i < n; i++) {
if (!col[i] && !dia1[i - index + n - 1] && !dia2[i + index]) {
________________________;
}
}
return res;
}
}
```
## template
```java
......@@ -72,7 +100,13 @@ class Solution {
## 答案
```java
col[i] = true;
dia1[i - index + n - 1] = true;
dia2[i + index] = true;
res += putQueen(n, index + 1);
col[i] = false;
dia1[i - index + n - 1] = false;
dia2[i + index] = false;
```
## 选项
......@@ -80,17 +114,35 @@ class Solution {
### A
```java
col[i] = false;
dia1[i - index + n - 1] = false;
dia2[i + index] = false;
res += putQueen(n, index + 1);
col[i] = true;
dia1[i - index + n - 1] = true;
dia2[i + index] = true;
```
### B
```java
col[i] = false;
dia1[i - index + n - 1] = false;
dia2[i + index] = false;
res += putQueen(n, index);
col[i] = true;
dia1[i - index + n - 1] = true;
dia2[i + index] = true;
```
### C
```java
col[i] = true;
dia1[i - index + n - 1] = true;
dia2[i + index] = true;
res += putQueen(n, index);
col[i] = false;
dia1[i - index + n - 1] = false;
dia2[i + index] = false;
```
\ No newline at end of file
data/3.dailycode高阶/2.java/6.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,55 @@
<p>给定一个仅包含 <code>0</code> 和 <code>1</code> 、大小为 <code>rows x cols</code> 的二维二进制矩阵，找出只包含 <code>1</code> 的最大矩形，并返回其面积。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0000-0099/0085.Maximal%20Rectangle/images/maximal.jpg" style="width: 402px; height: 322px;" /><pre><strong>输入：</strong>matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]<strong><br />输出：</strong>6<strong><br />解释：</strong>最大矩形如上图所示。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>matrix = []<strong><br />输出：</strong>0</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>matrix = [["0"]]<strong><br />输出：</strong>0</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>matrix = [["1"]]<strong><br />输出：</strong>1</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>matrix = [["0","0"]]<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>rows == matrix.length</code></li> <li><code>cols == matrix[0].length</code></li> <li><code>0 <= row, cols <= 200</code></li> <li><code>matrix[i][j]</code> 为 <code>'0'</code> 或 <code>'1'</code></li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public int maximalRectangle(char[][] matrix) {
if (matrix == null || matrix.length == 0)
return 0;
int m = matrix.length;
int n = matrix[0].length;
int[] left = new int[n];
int[] right = new int[n];
int[] height = new int[n];
Arrays.fill(right, n);
int cur_left = 0;
int cur_right = n;
int res = 0;
for (int i = 0; i < m; i++) {
cur_left = 0;
cur_right = n;
for (int j = 0; j < n; j++) {
if (matrix[i][j] == '1')
height[j]++;
else
height[j] = 0;
}
for (int j = 0; j < n; j++) {
if (matrix[i][j] == '1') {
left[j] = Math.max(left[j], cur_left);
} else {
left[j] = 0;
cur_left = j + 1;
}
}
for (int j = n - 1; j >= 0; j--) {
if (matrix[i][j] == '1') {
right[j] = Math.min(right[j], cur_right);
} else {
right[j] = n;
cur_right = j;
}
}
______________________;
}
return res;
}
}
```
## template
```java
......@@ -55,7 +104,8 @@ class Solution {
## 答案
```java
for (int j = 0; j < n; j++)
res = Math.max(res, (right[j] - left[j]) * height[j]);
```
## 选项
......@@ -63,17 +113,20 @@ class Solution {
### A
```java
for (int j = 0; j < n; j++)
res = Math.max(res, (right[j] + left[j]) * height[j]);
```
### B
```java
for (int j = 0; j < n; j++)
res = Math.max(res, (right[j] + left[j]) / 2 * height[j]);
```
### C
```java
for (int j = 0; j < n; j++)
res = Math.max(res, (right[j] - left[j]) / 2 * height[j]);
```
\ No newline at end of file
data/3.dailycode高阶/2.java/7.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,52 @@
<p>给你两个单词 <code>word1</code> 和 <code>word2</code>，请你计算出将 <code>word1</code> 转换成 <code>word2</code><em> </em>所使用的最少操作数 。</p><p>你可以对一个单词进行如下三种操作：</p><ul> <li>插入一个字符</li> <li>删除一个字符</li> <li>替换一个字符</li></ul><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>word1 = "horse", word2 = "ros"<strong><br />输出：</strong>3<strong><br />解释：</strong>horse -> rorse (将 'h' 替换为 'r')rorse -> rose (删除 'r')rose -> ros (删除 'e')</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>word1 = "intention", word2 = "execution"<strong><br />输出：</strong>5<strong><br />解释：</strong>intention -> inention (删除 't')inention -> enention (将 'i' 替换为 'e')enention -> exention (将 'n' 替换为 'x')exention -> exection (将 'n' 替换为 'c')exection -> execution (插入 'u')</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= word1.length, word2.length <= 500</code></li> <li><code>word1</code> 和 <code>word2</code> 由小写英文字母组成</li></ul>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public int minDistance(String word1, String word2) {
int len1 = word1.length();
int len2 = word2.length();
if (len1 * len2 == 0)
return len1 + len2;
String longerStr = len1 > len2 ? word1 : word2;
String shorterStr = len1 > len2 ? word2 : word1;
int shorterOne = Math.min(len1, len2);
int[] dp = new int[shorterOne + 1];
for (int i = 0; i < shorterOne + 1; i++) {
dp[i] = i;
}
for (int j = 1; j <= longerStr.length(); j++) {
int left = j;
for (int i = 1; i <= shorterStr.length(); i++) {
int updateDown = dp[i] + 1;
int updateLeft = left + 1;
int updateLeftDown = dp[i - 1];
if (longerStr.charAt(j - 1) != shorterStr.charAt(i - 1)) {
updateLeftDown++;
}
int min = Math.min(updateLeft, Math.min(updateDown, updateLeftDown));
dp[i - 1] = left;
_____________________;
}
}
return dp[shorterOne];
}
}
```
## template
```java
......@@ -56,7 +102,11 @@ class Solution {
## 答案
```java
if (i == dp.length - 1) {
dp[i] = min;
} else {
left = min;
}
```
## 选项
......@@ -64,17 +114,29 @@ class Solution {
### A
```java
if (i == dp.length) {
dp[i] = min;
} else {
left = min;
}
```
### B
```java
if (i == dp.length + 1) {
dp[i] = min;
} else {
left = min;
}
```
### C
```java
if (i == dp.length - 1) {
left = min;
} else {
dp[i] = min;
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/8.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -64,6 +64,53 @@
</pre>
</div>
以下程序实现了这一功能，请你填补空白处内容：
```java
class Solution {
public List<String> fullJustify(String[] words, int maxWidth) {
List<String> ret = new ArrayList<>();
int index = 0;
while (index < words.length) {
int cur = index, len = 0;
while (cur < words.length && len + words[cur].length() + cur - index <= maxWidth) {
len = len + words[cur++].length();
}
cur--;
StringBuilder sb = new StringBuilder();
if (cur == words.length - 1) {
for (int i = index; i <= cur; i++) {
sb.append(words[i]);
if (i < cur) {
sb.append(' ');
}
}
} else {
int base = cur > index ? (maxWidth - len) / (cur - index) : (maxWidth - len);
String baseStr = genSpace(base);
int left = cur > index ? (maxWidth - len) % (cur - index) : 0;
String leftStr = genSpace(base + 1);
for (int i = index; i <= cur; i++) {
sb.append(words[i]);
___________________;
}
}
if (sb.length() < maxWidth) {
sb.append(genSpace(maxWidth - sb.length()));
}
ret.add(sb.toString());
index = cur + 1;
}
return ret;
}
private String genSpace(int n) {
char[] cs = new char[n];
Arrays.fill(cs, ' ');
return new String(cs);
}
}
```
## template
```java
......@@ -117,7 +164,10 @@ class Solution {
## 答案
```java
if (i < cur) {
sb.append(left > 0 ? leftStr : baseStr);
left--;
}
```
## 选项
......@@ -125,17 +175,26 @@ class Solution {
### A
```java
if (i < cur) {
sb.append(left > 0 ? baseStr : leftStr);
left--;
}
```
### B
```java
if (i < cur) {
sb.append(left > 0 ? baseStr : leftStr);
left++;
}
```
### C
```java
if (i < cur) {
sb.append(left >= 0 ? leftStr : baseStr);
left--;
}
```
\ No newline at end of file
data/3.dailycode高阶/2.java/9.exercises/solution.md
浏览文件 @ c1efa19b
......@@ -2,6 +2,39 @@
<p>给你一个只包含 <code>'('</code> 和 <code>')'</code> 的字符串，找出最长有效（格式正确且连续）括号子串的长度。</p><p> </p><div class="original__bRMd"><div><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "(()"<strong><br />输出：</strong>2<strong><br />解释：</strong>最长有效括号子串是 "()"</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>s = ")()())"<strong><br />输出：</strong>4<strong><br />解释：</strong>最长有效括号子串是 "()()"</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = ""<strong><br />输出：</strong>0</pre><p> </p><p><strong>提示：</strong></p><ul> <li><code>0 <= s.length <= 3 * 10<sup>4</sup></code></li> <li><code>s[i]</code> 为 <code>'('</code> 或 <code>')'</code></li></ul></div></div>
以下程序实现了这一功能，请你填补空白处内容：
```java
import java.util.*;
class Solution {
public int longestValidParentheses(String s) {
int left = 0, right = 0, max = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(')
left++;
else
right++;
if (left == right)
max = Math.max(max, left * 2);
if (right > left)
left = right = 0;
}
left = 0;
right = 0;
for (int i = s.length() - 1; i >= 0; i--) {
__________________;
if (left == right)
max = Math.max(max, left * 2);
if (right < left)
left = right = 0;
}
return max;
}
}
```
## template
```java
......@@ -41,7 +74,10 @@ class Solution {
## 答案
```java
if (s.charAt(i) == '(')
left++;
else
right++;
```
## 选项
......@@ -49,17 +85,26 @@ class Solution {
### A
```java
if (s.charAt(i) == ')')
left++;
else
right++;
```
### B
```java
if (s.charAt(i) == '(')
right++;
else
left++;
```
### C
```java
if (s.charAt(i) == ')')
right++;
else
left++;
```
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或