Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

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

Provide feedback

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

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit90f64bd

Browse files
committed
fix: fix the format
1 parent722d859 commit90f64bd

File tree

35 files changed

+78
-78
lines changed

35 files changed

+78
-78
lines changed

‎README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@
2121
>美其名曰："practice makes perfect."
2222
>为何今不如古？
2323
>非也非也，
24-
>科举为国取士，LeetCode为Google筛码工，各取所需也。
24+
>科举为国取士，LeetCode 为 Google 筛码工，各取所需也。
2525
2626

2727
##Easy

‎note/001/README.md‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,9 +18,9 @@ return [0, 1].
1818
**Tags:** Array, Hash Table
1919

2020

21-
##思路0
21+
##思路 0
2222

23-
题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为`O(n^2)`，首次提交居然是2ms，打败了100%的提交，谜一样的结果，之后再次提交就再也没跑到过2ms了。
23+
题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为`O(n^2)`，首次提交居然是 2ms，打败了 100%的提交，谜一样的结果，之后再次提交就再也没跑到过 2ms 了。
2424

2525
```java
2626
classSolution {
@@ -37,9 +37,9 @@ class Solution {
3737
}
3838
```
3939

40-
##思路1
40+
##思路 1
4141

42-
利用HashMap作为存储，键为目标值减去当前元素值，索引为值，比如`i = 0`时，此时首先要判断`nums[0] = 2`是否在map中，如果不存在，那么插入键值对`key = 9 - 2 = 7, value = 0`，之后当`i = 1`时，此时判断`nums[1] = 7`已存在于map中，那么取出该`value = 0`作为第一个返回值，当前`i`作为第二个返回值，具体代码如下所示。
42+
利用 HashMap 作为存储，键为目标值减去当前元素值，索引为值，比如`i = 0`时，此时首先要判断`nums[0] = 2` 是否在 map 中，如果不存在，那么插入键值对`key = 9 - 2 = 7, value = 0`，之后当`i = 1`时，此时判断`nums[1] = 7` 已存在于 map 中，那么取出该`value = 0`作为第一个返回值，当前`i`作为第二个返回值，具体代码如下所示。
4343

4444
```java
4545
classSolution {

‎note/002/README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ Explanation: 342 + 465 = 807.
1919

2020
##思路
2121

22-
题意我也是看了好久才看懂，就是以链表表示一个数，低位在前，高位在后，所以题中的例子就是`342 + 465 = 807`，所以我们模拟计算即可。
22+
题意我也是看了好久才看懂，就是以链表表示一个数，低位在前，高位在后，所以题中的例子就是`342 + 465 = 807`，所以我们模拟计算即可。
2323

2424
```java
2525
/**

‎note/003/README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ Given `"pwwkew"`, the answer is `"wke"`, with the length of 3. Note that the ans
1717

1818
##思路
1919

20-
题意是计算不带重复字符的最长子字符串的长度，开辟一个hash数组来存储该字符上次出现的位置，比如`hash[a] = 3`就是代表`a`字符前一次出现的索引在3，遍历该字符串，获取到上次出现的最大索引（只能向前，不能退后），与当前的索引做差获取的就是本次所需长度，从中迭代出最大值就是最终答案。
20+
题意是计算不带重复字符的最长子字符串的长度，开辟一个 hash 数组来存储该字符上次出现的位置，比如`hash[a] = 3`就是代表`a` 字符前一次出现的索引在 3，遍历该字符串，获取到上次出现的最大索引（只能向前，不能退后），与当前的索引做差获取的就是本次所需长度，从中迭代出最大值就是最终答案。
2121

2222
```java
2323
classSolution {

‎note/005/README.md‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ Output: "bb"
2525
**Tags:** String
2626

2727

28-
##思路0
28+
##思路 0
2929

3030
题意是寻找出字符串中最长的回文串，所谓回文串就是正序和逆序相同的字符串，也就是关于中间对称。我们先用最常规的做法，依次去求得每个字符的最长回文，要注意每个字符有奇数长度的回文串和偶数长度的回文串两种情况，相信你可以很轻易地从如下代码中找到相关代码，记录最长回文的始末位置即可，时间复杂度的话，首先要遍历一遍字符串，然后对每个字符都去求得最长回文，所以时间复杂度为`O(n^2)`。
3131

@@ -58,9 +58,9 @@ class Solution {
5858
```
5959

6060

61-
##思路1
61+
##思路 1
6262

63-
如果利用暴力法遍历所有字串是否回文的情况这道题肯定是`Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义`dp[i][j]` 的意思为字符串区间`[i, j]`是否为回文串，那么我们分三种情况：
63+
如果利用暴力法遍历所有字串是否回文的情况这道题肯定是`Time Limit Exceeded` 的，那么我们是否可以把之前遍历的结果利用上呢，那么动态规划的想法就呼之欲出了，我们定义`dp[i][j]` 的意思为字符串区间`[i, j]`是否为回文串，那么我们分三种情况：
6464

6565
1. 当`i == j` 时，那么毫无疑问`dp[i][j] = true`；
6666

@@ -98,7 +98,7 @@ class Solution {
9898
```
9999

100100

101-
##思路2
101+
##思路 2
102102

103103
马拉车算法(Manacher's Algorithm)
104104

@@ -112,11 +112,11 @@ class Solution {
112112

113113
3. s = "abcde"，最长回文长度为`1`，即单个字符本身。
114114

115-
这个问题等同于LeetCode上的[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
115+
这个问题等同于 LeetCode 上的[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)，其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)
116116

117117
以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为`O(n^2)`，效率很差。
118118

119-
1975年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到`O(n)`，下面我以我理解的思路来讲解其原理。
119+
1975 年，一个叫 Manacher 的人发明了 Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到`O(n)`，下面我以我理解的思路来讲解其原理。
120120

121121

122122
###分析

‎note/007/README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ Assume we are dealing with an environment which could only hold integers within
3434

3535
##思路
3636

37-
题意是给你一个整型数，求它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回0，用我们代码表示的话可以求得结果保存在long中，最后把结果和整型的两个范围比较即可。
37+
题意是给你一个整型数，求它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回 0，用我们代码表示的话可以求得结果保存在 long 中，最后把结果和整型的两个范围比较即可。
3838

3939
```java
4040
classSolution {

‎note/008/README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ If no valid conversion could be performed, a zero value is returned. If the corr
2525

2626
##思路
2727

28-
题意是把一个字符串转为整型，但要注意所给的要求，先去除最前面的空格，然后判断正负数，注意正数可能包含`+`，如果之后存在非数字或全为空则返回`0`，而如果合法的值超过int表示的最大范围，则根据正负号返回`INT_MAX`或`INT_MIN`。
28+
题意是把一个字符串转为整型，但要注意所给的要求，先去除最前面的空格，然后判断正负数，注意正数可能包含`+`，如果之后存在非数字或全为空则返回`0`，而如果合法的值超过 int 表示的最大范围，则根据正负号返回`INT_MAX` 或`INT_MIN`。
2929

3030
```java
3131
classSolution {

‎note/009/README.md‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ There is a more generic way of solving this problem.
1919
**Tags:** Math
2020

2121

22-
##思路0
22+
##思路 0
2323

2424
题意是判断一个有符号整型数是否是回文，也就是逆序过来的整数和原整数相同，首先负数肯定不是，接下来我们分析一下最普通的解法，就是直接算出他的回文数，然后和给定值比较即可。
2525

@@ -37,9 +37,9 @@ class Solution {
3737
}
3838
```
3939

40-
##思路1
40+
##思路 1
4141

42-
好好思考下是否需要计算整个长度，比如1234321，其实不然，我们只需要计算一半的长度即可，就是在计算过程中的那个逆序数比不断除10的数大就结束计算即可，但是这也带来了另一个问题，比如10的倍数的数10010，它也会返回`true`，所以我们需要对10的倍数的数再加个判断即可，代码如下所示。
42+
好好思考下是否需要计算整个长度，比如 1234321，其实不然，我们只需要计算一半的长度即可，就是在计算过程中的那个逆序数比不断除 10 的数大就结束计算即可，但是这也带来了另一个问题，比如 10 的倍数的数 10010，它也会返回`true`，所以我们需要对 10 的倍数的数再加个判断即可，代码如下所示。
4343

4444
```java
4545
publicboolean isPalindrome(int x) {

‎note/010/README.md‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -26,19 +26,19 @@ isMatch("aab", "c*a*b") → true
2626
**Tags:** String, Dynamic Programming, Backtracking
2727

2828

29-
##思路0
29+
##思路 0
3030

31-
题意是让让你从判断`s`字符串是否正则匹配于`p`，这道题和[Wildcard Matching][044]很是相似，区别在于`*`，通配符的`*`是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的`*`不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括0个。首先我们用递归的方式来实现，其思路如下：
31+
题意是让让你从判断`s`字符串是否正则匹配于`p`，这道题和[Wildcard Matching][044]很是相似，区别在于`*`，通配符的`*`是可以随意出现的，跟前面字符没有任何关系，其作用是可以表示任意字符串；而正则匹配的`*`不能单独存在，前面必须具有一个字符，其意义是表明前面的这个字符个数可以是任意个数，包括 0 个。首先我们用递归的方式来实现，其思路如下：
3232

33-
* 如果`s`和`p`都为空，那么返回`true`；
33+
* 如果`s` 和`p`都为空，那么返回`true`；
3434

35-
* 如果`p`的长度为1，当`s`的长度也为1，并且他们首位匹配则返回`true`，否则返回`false`；
35+
* 如果`p` 的长度为 1，当`s` 的长度也为 1，并且他们首位匹配则返回`true`，否则返回`false`；
3636

37-
* 如果`p`的第二个字符不为 '*'，如果`s`为空，那就返回`false`，首位匹配则返回递归调用他们去掉首位的子字符串，否则返回`false`；
37+
* 如果`p`的第二个字符不为 '*'，如果`s`为空，那就返回`false`，首位匹配则返回递归调用他们去掉首位的子字符串，否则返回`false`；
3838

39-
* 如果`p`的第二个字符为 '*'，循环当`s`不为空，且首位匹配，如果递归调用是否匹配`s`字符串和`p`去掉前两位的子字符串，则返回`true`，否则`s`去掉首字母继续循环；
39+
* 如果`p`的第二个字符为 '*'，循环当`s`不为空，且首位匹配，如果递归调用是否匹配`s`字符串和`p`去掉前两位的子字符串，则返回`true`，否则`s`去掉首字母继续循环；
4040

41-
* 返回递归调用`s`字符串和`p`去掉前两位的子字符串是否匹配。
41+
* 返回递归调用`s`字符串和`p`去掉前两位的子字符串是否匹配。
4242

4343
```java
4444
classSolution {
@@ -64,15 +64,15 @@ class Solution {
6464
```
6565

6666

67-
##思路1
67+
##思路 1
6868

6969
我们可以把上面的思路更简单化，如下：
7070

71-
* 如果`s`和`p`都为空，那么返回`true`；
71+
* 如果`s` 和`p`都为空，那么返回`true`；
7272

73-
* 如果`p`的第二个字符为`*`，由于`*`前面的字符个数可以为任意，那么我们先递归调用个数为0的情况；或者当`s`不为空，如果他们的首字母匹配，那么我们就递归调用去掉去掉首字母的`s`和完整的`p`；
73+
* 如果`p`的第二个字符为`*`，由于`*`前面的字符个数可以为任意，那么我们先递归调用个数为 0 的情况；或者当`s`不为空，如果他们的首字母匹配，那么我们就递归调用去掉去掉首字母的`s`和完整的`p`；
7474

75-
* 如果`p`的第二个字符不为`*`，那么我们就老老实实判断第一个字符是否匹配并且递归调用他们去掉首位的子字符串。
75+
* 如果`p`的第二个字符不为`*`，那么我们就老老实实判断第一个字符是否匹配并且递归调用他们去掉首位的子字符串。
7676

7777
```java
7878
classSolution {
@@ -89,13 +89,13 @@ class Solution {
8989
}
9090
```
9191

92-
##思路2
92+
##思路 2
9393

94-
另一种思路就是动态规划了，我们定义`dp[i][j]`的真假来表示`s[0..i)`是否匹配`p[0..j)`，通过思路1，我们可以确定其状态转移方程如下所示：
94+
另一种思路就是动态规划了，我们定义`dp[i][j]`的真假来表示`s[0..i)`是否匹配`p[0..j)`，通过思路 1，我们可以确定其状态转移方程如下所示：
9595

96-
* 如果`p[j - 1] == '*'`,`dp[i][j] = dp[i][j - 2] || (pc[j - 2] == sc[i - 1] || pc[j - 2] == '.') && dp[i - 1][j];`；
96+
* 如果`p[j - 1] == '*'`,`dp[i][j] = dp[i][j - 2] || (pc[j - 2] == sc[i - 1] || pc[j - 2] == '.') && dp[i - 1][j];`；
9797

98-
* 如果`p[j - 1] != '*'`，`dp[i][j] = dp[i - 1][j - 1] && (pc[j - 1] == '.' || pc[j - 1] == sc[i - 1]);`。
98+
* 如果`p[j - 1] != '*'`，`dp[i][j] = dp[i - 1][j - 1] && (pc[j - 1] == '.' || pc[j - 1] == sc[i - 1]);`。
9999

100100
```java
101101
classSolution {

‎note/013/README.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,15 +11,15 @@ Input is guaranteed to be within the range from 1 to 3999.
1111

1212
##思路
1313

14-
题意是罗马数字转整型数，范围从1到3999，查看下百度百科的罗马数字介绍如下：
14+
题意是罗马数字转整型数，范围从 1 到 3999，查看下百度百科的罗马数字介绍如下：
1515

1616
* 相同的数字连写，所表示的数等于这些数字相加得到的数，如 Ⅲ=3；
1717

1818
* 小的数字在大的数字的右边，所表示的数等于这些数字相加得到的数，如 Ⅷ=8、Ⅻ=12；
1919

2020
* 小的数字（限于 Ⅰ、X 和 C）在大的数字的左边，所表示的数等于大数减小数得到的数，如 Ⅳ=4、Ⅸ=9。
2121

22-
那么我们可以利用map来完成罗马数字的7个数字符号：I、V、X、L、C、D、M和整数的映射关系，然后根据上面的解释来模拟完成即可。
22+
那么我们可以利用 map 来完成罗马数字的 7 个数字符号：I、V、X、L、C、D、M 和整数的映射关系，然后根据上面的解释来模拟完成即可。
2323

2424
```java
2525
classSolution {

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp