diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 479c809d..79766c8d 100644
--- a/docs/notes/Java 基础.md
+++ b/docs/notes/Java 基础.md
@@ -1141,7 +1141,7 @@ System.out.println(InterfaceExample.x);
使用接口：
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Comparable 接口中的 compareTo() 方法；
- 需要使用多重继承。
使用抽象类：
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index 82de0416..1a6e0cff 100644
--- a/docs/notes/Java 虚拟机.md
+++ b/docs/notes/Java 虚拟机.md
@@ -521,7 +521,7 @@ public static final int value = 123;
其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
-### 5. 初始化
+### 5. 初始化
初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 <clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
diff --git a/docs/notes/Leetcode 题解 - 位运算.md b/docs/notes/Leetcode 题解 - 位运算.md
index a6a913c4..35e72dd7 100644
--- a/docs/notes/Leetcode 题解 - 位运算.md
+++ b/docs/notes/Leetcode 题解 - 位运算.md
@@ -1,5 +1,4 @@
-* [0. 原理](#0-原理)
* [1. 统计两个数的二进制表示有多少位不同](#1-统计两个数的二进制表示有多少位不同)
* [2. 数组中唯一一个不重复的元素](#2-数组中唯一一个不重复的元素)
* [3. 找出数组中缺失的那个数](#3-找出数组中缺失的那个数)
@@ -16,9 +15,7 @@
-# 0. 原理
-
-**基本原理**
+**基本原理**
0s 表示一串 0，1s 表示一串 1。
@@ -28,79 +25,23 @@ x ^ 1s = ~x x & 1s = x x | 1s = 1s
x ^ x = 0 x & x = x x | x = x
```
-利用 x ^ 1s = \~x 的特点，可以将一个数的位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
-```
-1^1^2 = 2
-```
+位与运算技巧：
-利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
+- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
-```
-01011011 &
-00111100
---------
-00011000
-```
+移位运算：
-利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
+- \>\> n 为算术右移，相当于除以 2n；
+- \>\>\> n 为无符号右移，左边会补上 0。
+- << n 为算术左移，相当于乘以 2n。
-```
-01011011 |
-00111100
---------
-01111111
-```
-
-**位与运算技巧**
-
-n&(n-1) 去除 n 的位级表示中最低的那一位 1。例如对于二进制表示 01011011，减去 1 得到 01011010，这两个数相与得到 01011010。
-
-```
-01011011 &
-01011010
---------
-01011010
-```
-
-n&(-n) 得到 n 的位级表示中最低的那一位 1。-n 得到 n 的反码加 1，也就是 -n=\~n+1。例如对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
-
-```
-10110100 &
-01001100
---------
-00000100
-```
-
-n-(n&(-n)) 则可以去除 n 的位级表示中最低的那一位 1，和 n&(n-1) 效果一样。
-
-**移位运算**
-
-\>\> n 为算术右移，相当于除以 2n，例如 -7 >> 2 = -2。
-
-```
-11111111111111111111111111111001 >> 2
---------
-11111111111111111111111111111110
-```
-
-\>\>\> n 为无符号右移，左边会补上 0。例如 -7 >>> 2 = 1073741822。
-
-```
-11111111111111111111111111111001 >>> 2
---------
-00111111111111111111111111111111
-```
-
-<< n 为算术左移，相当于乘以 2n。-7 << 2 = -28。
-
-```
-11111111111111111111111111111001 << 2
---------
-11111111111111111111111111100100
-```
-
-**mask 计算**
+** mask 计算**
要获取 111111111，将 0 取反即可，\~0。
diff --git a/docs/notes/Leetcode 题解 - 搜索.md b/docs/notes/Leetcode 题解 - 搜索.md
index 0e245d4c..9f14efbd 100644
--- a/docs/notes/Leetcode 题解 - 搜索.md
+++ b/docs/notes/Leetcode 题解 - 搜索.md
@@ -34,7 +34,7 @@
-广度优先搜索一层一层地进行遍历，每层遍历都是以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
+广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
第一层：
@@ -75,39 +75,33 @@
题目描述：0 表示可以经过某个位置，求解从左上角到右下角的最短路径长度。
```java
- public int shortestPathBinaryMatrix(int[][] grids) {
- if (grids == null || grids.length == 0 || grids[0].length == 0) {
- return -1;
- }
- int[][] direction = {{1, -1}, {1, 0}, {1, 1}, {0, -1}, {0, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
- int m = grids.length, n = grids[0].length;
- Queue> queue = new LinkedList<>();
- queue.add(new Pair<>(0, 0));
- int pathLength = 0;
- while (!queue.isEmpty()) {
- int size = queue.size();
- pathLength++;
- while (size-- > 0) {
- Pair cur = queue.poll();
- int cr = cur.getKey(), cc = cur.getValue();
- if (grids[cr][cc] == 1) {
+public int shortestPathBinaryMatrix(int[][] grids) {
+ int[][] direction = {{1, -1}, {1, 0}, {1, 1}, {0, -1}, {0, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
+ int m = grids.length, n = grids[0].length;
+ Queue> queue = new LinkedList<>();
+ queue.add(new Pair<>(0, 0));
+ int pathLength = 0;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ pathLength++;
+ while (size-- > 0) {
+ Pair cur = queue.poll();
+ int cr = cur.getKey(), cc = cur.getValue();
+ grids[cr][cc] = 1; // 标记
+ for (int[] d : direction) {
+ int nr = cr + d[0], nc = cc + d[1];
+ if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 1) {
continue;
}
- if (cr == m - 1 && cc == n - 1) {
- return pathLength;
- }
- grids[cr][cc] = 1; // 标记
- for (int[] d : direction) {
- int nr = cr + d[0], nc = cc + d[1];
- if (nr < 0 || nr >= m || nc < 0 || nc >= n) {
- continue;
- }
- queue.add(new Pair<>(nr, nc));
+ if (nr == m - 1 && nc == n - 1) {
+ return pathLength + 1;
}
+ queue.add(new Pair<>(nr, nc));
}
}
- return -1;
}
+ return -1;
+}
```
## 2. 组成整数的最小平方数数量
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index b62acfbe..ec1e31af 100644
--- a/docs/notes/Leetcode-Database 题解.md
+++ b/docs/notes/Leetcode-Database 题解.md
@@ -827,7 +827,7 @@ https://leetcode.com/problems/rank-scores/description/
| 2 | 4.2 | 2 | 2 |
| 3 | 4.3 | 1 | 1 |
-使用连接操作找到某个 score 对应的大于等于其值的记录：
+使用连接操作找到某个 score 对应的大于其值的记录：
```sql
SELECT
@@ -890,7 +890,7 @@ ORDER BY
| score | Rank |
| :---: | :--: |
| 4.2 | 1 |
-| 4.2 | 1 |
+| 4.2 | 2 |
| 4.1 | 2 |
连接情况如下：
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 2f715fb4..1280ba40 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1021,7 +1021,7 @@ g/re/p（globally search a regular expression and print)，使用正则表示式
```html
$ grep [-acinv] [--color=auto] 搜寻字符串 filename
--c ： 统计匹配到行的个数
+-c ： 统计个数
-i ： 忽略大小写
-n ： 输出行号
-v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
@@ -1039,7 +1039,7 @@ $ grep -n 'the' regular_express.txt
18:google is the best tools for search keyword
```
-示例：正则表达式 a{m,n} 用来匹配字符 a m\~n 次，这里需要将 { 和 } 进行转义，因为它们在 shell 是有特殊意义的。
+示例：正则表达式 a{m,n} 用来匹配字符 a m\~n 次，这里需要将 { 和 } 进行转移，因为它们在 shell 是有特殊意义的。
```html
$ grep -n 'a\{2,5\}' regular_express.txt
diff --git a/docs/notes/剑指 Offer 题解 - 目录.md b/docs/notes/剑指 Offer 题解 - 目录.md
index f9dcd846..a7c246bc 100644
--- a/docs/notes/剑指 Offer 题解 - 目录.md
+++ b/docs/notes/剑指 Offer 题解 - 目录.md
@@ -1,10 +1,3 @@
-# 前言
-
-题目来自《何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.》，刷题网站推荐：
-
-- [牛客网](https://www.nowcoder.com/ta/coding-interviews?from=cyc_github)
-- [Leetcode](https://leetcode-cn.com/problemset/lcof/)
-
# 目录
@@ -85,6 +78,10 @@
- [67. 把字符串转换成整数](67.%20把字符串转换成整数.md)
- [68. 树中两个节点的最低公共祖先](68.%20树中两个节点的最低公共祖先.md)
+# 参考文献
+
+何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
+
diff --git a/docs/notes/计算机操作系统 - 内存管理.md b/docs/notes/计算机操作系统 - 内存管理.md
index 62b6d6f6..ae31fdaf 100644
--- a/docs/notes/计算机操作系统 - 内存管理.md
+++ b/docs/notes/计算机操作系统 - 内存管理.md
@@ -73,7 +73,6 @@
```
-
## 3. 最近未使用
> NRU, Not Recently Used
@@ -89,7 +88,7 @@
NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。
-## 4. 先进先出
+## 4. 先进先出
> FIFO, First In First Out
diff --git a/notes/67. 把字符串转换成整数.md b/notes/67. 把字符串转换成整数.md
index 74e862d2..db736fa8 100644
--- a/notes/67. 把字符串转换成整数.md
+++ b/notes/67. 把字符串转换成整数.md
@@ -22,53 +22,20 @@ Output:
```java
public int StrToInt(String str) {
- if (str == null)
+ if (str == null || str.length() == 0)
+ return 0;
+ boolean isNegative = str.charAt(0) == '-';
+ int ret = 0;
+ for (int i = 0; i < str.length(); i++) {
+ char c = str.charAt(i);
+ if (i == 0 && (c == '+' || c == '-')) /* 符号判定 */
+ continue;
+ if (c < '0' || c > '9') /* 非法输入 */
return 0;
- int result = 0;
- boolean negative = false;//是否负数
- int i = 0, len = str.length();
- /**
- * limit 默认初始化为*负的*最大正整数 ，假如字符串表示的是正数
- * 由于int的范围为-2147483648~2147483647
- * 那么result(在返回之前一直是负数形式)就必须和这个最大正数的负数来比较来判断是否溢出，
- */
- int limit = - Integer.MAX_VALUE;
- int multmin;
- int digit;
-
- if (len > 0) {
- char firstChar = str.charAt(0);//首先看第一位
- if (firstChar < '0') { // 有可能是 "+" or "-"
- if (firstChar == '-') {
- negative = true;
- limit = Integer.MIN_VALUE;//在负号的情况下，判断溢出的值就变成了 整数的 最小负数了
- } else if (firstChar != '+')//第一位不是数字和-只能是+
- return 0;
- if (len == 1) // Cannot have lone "+" or "-"
- return 0;
- i++;
- }
- multmin = limit / 10;
- while (i < len) {
- digit = str.charAt(i++)-'0';
- if (digit < 0 || digit > 9)
- return 0;
- //判断溢出
- if (result < multmin) {
- return 0;
- }
- result *= 10;
- if (result < limit + digit) {
- return 0;
- }
- result -= digit;
- }
- } else {
- return 0;
- }
- //如果是正数就返回-result（result一直是负数）
- return negative ? result : -result;
+ ret = ret * 10 + (c - '0');
}
+ return isNegative ? -ret : ret;
+}
```
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index b1335ed7..79766c8d 100644
--- a/notes/Java 基础.md
+++ b/notes/Java 基础.md
@@ -1141,7 +1141,7 @@ System.out.println(InterfaceExample.x);
使用接口：
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Comparable 接口中的 compareTo() 方法；
- 需要使用多重继承。
使用抽象类：
@@ -1432,9 +1432,8 @@ Java 注解是附加在代码中的一些元信息，用于一些工具在编译
## JRE or JDK
-- JRE：Java Runtime Environment，java运行环境的简称，为java的运行提供了所需的环境。主要包括了JVM的标准实现和一些java基本类库。
-- JDK：Java Development Kit，java开发工具包，提供了java的开发及运行环境。JDK是java开发的核心，集成了JRE以及一些其他的工具，比如编译 java 源码的编译器 javac等。
-- 因此可以这样认为：JDK>JRE>JVM，JRE支持了java程序的运行，而JDK则同时支持了java程序的开发。
+- JRE is the JVM program, Java application need to run on JRE.
+- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
# 参考资料
diff --git a/notes/Java 虚拟机.md b/notes/Java 虚拟机.md
index 82de0416..1a6e0cff 100644
--- a/notes/Java 虚拟机.md
+++ b/notes/Java 虚拟机.md
@@ -521,7 +521,7 @@ public static final int value = 123;
其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
-### 5. 初始化
+### 5. 初始化
初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 <clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
diff --git a/notes/Leetcode 题解 - 位运算.md b/notes/Leetcode 题解 - 位运算.md
index a6a913c4..35e72dd7 100644
--- a/notes/Leetcode 题解 - 位运算.md
+++ b/notes/Leetcode 题解 - 位运算.md
@@ -1,5 +1,4 @@
-* [0. 原理](#0-原理)
* [1. 统计两个数的二进制表示有多少位不同](#1-统计两个数的二进制表示有多少位不同)
* [2. 数组中唯一一个不重复的元素](#2-数组中唯一一个不重复的元素)
* [3. 找出数组中缺失的那个数](#3-找出数组中缺失的那个数)
@@ -16,9 +15,7 @@
-# 0. 原理
-
-**基本原理**
+**基本原理**
0s 表示一串 0，1s 表示一串 1。
@@ -28,79 +25,23 @@ x ^ 1s = ~x x & 1s = x x | 1s = 1s
x ^ x = 0 x & x = x x | x = x
```
-利用 x ^ 1s = \~x 的特点，可以将一个数的位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
-```
-1^1^2 = 2
-```
+位与运算技巧：
-利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
+- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
-```
-01011011 &
-00111100
---------
-00011000
-```
+移位运算：
-利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
+- \>\> n 为算术右移，相当于除以 2n；
+- \>\>\> n 为无符号右移，左边会补上 0。
+- << n 为算术左移，相当于乘以 2n。
-```
-01011011 |
-00111100
---------
-01111111
-```
-
-**位与运算技巧**
-
-n&(n-1) 去除 n 的位级表示中最低的那一位 1。例如对于二进制表示 01011011，减去 1 得到 01011010，这两个数相与得到 01011010。
-
-```
-01011011 &
-01011010
---------
-01011010
-```
-
-n&(-n) 得到 n 的位级表示中最低的那一位 1。-n 得到 n 的反码加 1，也就是 -n=\~n+1。例如对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
-
-```
-10110100 &
-01001100
---------
-00000100
-```
-
-n-(n&(-n)) 则可以去除 n 的位级表示中最低的那一位 1，和 n&(n-1) 效果一样。
-
-**移位运算**
-
-\>\> n 为算术右移，相当于除以 2n，例如 -7 >> 2 = -2。
-
-```
-11111111111111111111111111111001 >> 2
---------
-11111111111111111111111111111110
-```
-
-\>\>\> n 为无符号右移，左边会补上 0。例如 -7 >>> 2 = 1073741822。
-
-```
-11111111111111111111111111111001 >>> 2
---------
-00111111111111111111111111111111
-```
-
-<< n 为算术左移，相当于乘以 2n。-7 << 2 = -28。
-
-```
-11111111111111111111111111111001 << 2
---------
-11111111111111111111111111100100
-```
-
-**mask 计算**
+** mask 计算**
要获取 111111111，将 0 取反即可，\~0。
diff --git a/notes/Leetcode 题解 - 动态规划.md b/notes/Leetcode 题解 - 动态规划.md
index ce38ffeb..305174be 100644
--- a/notes/Leetcode 题解 - 动态规划.md
+++ b/notes/Leetcode 题解 - 动态规划.md
@@ -139,7 +139,7 @@ private int rob(int[] nums, int first, int last) {
## 4. 信件错排
-题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信方式的数量（所有信封都没有装各自的信）。
+题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信方式的数量。
定义一个数组 dp 存储错误方式数量，dp[i] 表示前 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况：
@@ -1055,10 +1055,7 @@ public int combinationSum4(int[] nums, int target) {
题目描述：交易之后需要有一天的冷却时间。
-
-该题为马尔可夫过程，分为A观望，B持股，C冷却三个状态
-状态转移图：A-(观望)->A, A-(买入｜-price)->B, B-(观望)->B, B-(卖出|+price)->C, C-(冷却)->A
-可用维特比算法求解
+ 
```java
public int maxProfit(int[] prices) {
@@ -1066,17 +1063,19 @@ public int maxProfit(int[] prices) {
return 0;
}
int N = prices.length;
- int[] A = new int[N];
- int[] B = new int[N];
- int[] C = new int[N];
- A[0] = 0;
- B[0] = C[0] = -prices[0];
+ int[] buy = new int[N];
+ int[] s1 = new int[N];
+ int[] sell = new int[N];
+ int[] s2 = new int[N];
+ s1[0] = buy[0] = -prices[0];
+ sell[0] = s2[0] = 0;
for (int i = 1; i < N; i++) {
- A[i] = Math.max(A[i - 1], C[i - 1]);
- B[i] = Math.max(B[i - 1], A[i - 1] - prices[i]);
- C[i] = B[i - 1] + prices[i];
+ buy[i] = s2[i - 1] - prices[i];
+ s1[i] = Math.max(buy[i - 1], s1[i - 1]);
+ sell[i] = Math.max(buy[i - 1], s1[i - 1]) + prices[i];
+ s2[i] = Math.max(s2[i - 1], sell[i - 1]);
}
- return Math.max(A[N - 1], C[N - 1]);
+ return Math.max(sell[N - 1], s2[N - 1]);
}
```
@@ -1099,22 +1098,24 @@ The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
题目描述：每交易一次，都要支付一定的费用。
-
-分为A观望，B持股，两个状态
-状态转移图：A-(观望)->A, A-(买入|-price)->B, B-(观望)->B, B-(卖出|+price|-fee)->A
+ 
```java
public int maxProfit(int[] prices, int fee) {
int N = prices.length;
- int[] A = new int[N];
- int[] B = new int[N];
- A[0] = 0;
- B[0] = -prices[0];
+ int[] buy = new int[N];
+ int[] s1 = new int[N];
+ int[] sell = new int[N];
+ int[] s2 = new int[N];
+ s1[0] = buy[0] = -prices[0];
+ sell[0] = s2[0] = 0;
for (int i = 1; i < N; i++) {
- A[i] = Math.max(A[i - 1], B[i - 1] + prices[i] -fee);
- B[i] = Math.max(A[i - 1] - prices[i], B[i - 1]);
+ buy[i] = Math.max(sell[i - 1], s2[i - 1]) - prices[i];
+ s1[i] = Math.max(buy[i - 1], s1[i - 1]);
+ sell[i] = Math.max(buy[i - 1], s1[i - 1]) - fee + prices[i];
+ s2[i] = Math.max(s2[i - 1], sell[i - 1]);
}
- return A[N - 1];
+ return Math.max(sell[N - 1], s2[N - 1]);
}
```
diff --git a/notes/Leetcode 题解 - 搜索.md b/notes/Leetcode 题解 - 搜索.md
index 0e245d4c..9f14efbd 100644
--- a/notes/Leetcode 题解 - 搜索.md
+++ b/notes/Leetcode 题解 - 搜索.md
@@ -34,7 +34,7 @@
-广度优先搜索一层一层地进行遍历，每层遍历都是以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
+广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
第一层：
@@ -75,39 +75,33 @@
题目描述：0 表示可以经过某个位置，求解从左上角到右下角的最短路径长度。
```java
- public int shortestPathBinaryMatrix(int[][] grids) {
- if (grids == null || grids.length == 0 || grids[0].length == 0) {
- return -1;
- }
- int[][] direction = {{1, -1}, {1, 0}, {1, 1}, {0, -1}, {0, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
- int m = grids.length, n = grids[0].length;
- Queue> queue = new LinkedList<>();
- queue.add(new Pair<>(0, 0));
- int pathLength = 0;
- while (!queue.isEmpty()) {
- int size = queue.size();
- pathLength++;
- while (size-- > 0) {
- Pair cur = queue.poll();
- int cr = cur.getKey(), cc = cur.getValue();
- if (grids[cr][cc] == 1) {
+public int shortestPathBinaryMatrix(int[][] grids) {
+ int[][] direction = {{1, -1}, {1, 0}, {1, 1}, {0, -1}, {0, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
+ int m = grids.length, n = grids[0].length;
+ Queue> queue = new LinkedList<>();
+ queue.add(new Pair<>(0, 0));
+ int pathLength = 0;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ pathLength++;
+ while (size-- > 0) {
+ Pair cur = queue.poll();
+ int cr = cur.getKey(), cc = cur.getValue();
+ grids[cr][cc] = 1; // 标记
+ for (int[] d : direction) {
+ int nr = cr + d[0], nc = cc + d[1];
+ if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 1) {
continue;
}
- if (cr == m - 1 && cc == n - 1) {
- return pathLength;
- }
- grids[cr][cc] = 1; // 标记
- for (int[] d : direction) {
- int nr = cr + d[0], nc = cc + d[1];
- if (nr < 0 || nr >= m || nc < 0 || nc >= n) {
- continue;
- }
- queue.add(new Pair<>(nr, nc));
+ if (nr == m - 1 && nc == n - 1) {
+ return pathLength + 1;
}
+ queue.add(new Pair<>(nr, nc));
}
}
- return -1;
}
+ return -1;
+}
```
## 2. 组成整数的最小平方数数量
diff --git a/notes/Leetcode-Database 题解.md b/notes/Leetcode-Database 题解.md
index b62acfbe..ec1e31af 100644
--- a/notes/Leetcode-Database 题解.md
+++ b/notes/Leetcode-Database 题解.md
@@ -827,7 +827,7 @@ https://leetcode.com/problems/rank-scores/description/
| 2 | 4.2 | 2 | 2 |
| 3 | 4.3 | 1 | 1 |
-使用连接操作找到某个 score 对应的大于等于其值的记录：
+使用连接操作找到某个 score 对应的大于其值的记录：
```sql
SELECT
@@ -890,7 +890,7 @@ ORDER BY
| score | Rank |
| :---: | :--: |
| 4.2 | 1 |
-| 4.2 | 1 |
+| 4.2 | 2 |
| 4.1 | 2 |
连接情况如下：
diff --git a/notes/Linux.md b/notes/Linux.md
index 2f715fb4..1280ba40 100644
--- a/notes/Linux.md
+++ b/notes/Linux.md
@@ -1021,7 +1021,7 @@ g/re/p（globally search a regular expression and print)，使用正则表示式
```html
$ grep [-acinv] [--color=auto] 搜寻字符串 filename
--c ： 统计匹配到行的个数
+-c ： 统计个数
-i ： 忽略大小写
-n ： 输出行号
-v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
@@ -1039,7 +1039,7 @@ $ grep -n 'the' regular_express.txt
18:google is the best tools for search keyword
```
-示例：正则表达式 a{m,n} 用来匹配字符 a m\~n 次，这里需要将 { 和 } 进行转义，因为它们在 shell 是有特殊意义的。
+示例：正则表达式 a{m,n} 用来匹配字符 a m\~n 次，这里需要将 { 和 } 进行转移，因为它们在 shell 是有特殊意义的。
```html
$ grep -n 'a\{2,5\}' regular_express.txt
diff --git a/notes/剑指 Offer 题解 - 目录.md b/notes/剑指 Offer 题解 - 目录.md
index f9dcd846..a7c246bc 100644
--- a/notes/剑指 Offer 题解 - 目录.md
+++ b/notes/剑指 Offer 题解 - 目录.md
@@ -1,10 +1,3 @@
-# 前言
-
-题目来自《何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.》，刷题网站推荐：
-
-- [牛客网](https://www.nowcoder.com/ta/coding-interviews?from=cyc_github)
-- [Leetcode](https://leetcode-cn.com/problemset/lcof/)
-
# 目录
@@ -85,6 +78,10 @@
- [67. 把字符串转换成整数](67.%20把字符串转换成整数.md)
- [68. 树中两个节点的最低公共祖先](68.%20树中两个节点的最低公共祖先.md)
+# 参考文献
+
+何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
+
diff --git a/notes/算法 - 符号表.md b/notes/算法 - 符号表.md
index 133ed8af..c2b23ca5 100644
--- a/notes/算法 - 符号表.md
+++ b/notes/算法 - 符号表.md
@@ -245,13 +245,13 @@ public class BinarySearchOrderedST, Value> implement
**二叉树** 是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
- 
+ 
**二叉查找树** （BST）是一颗二叉树，并且每个节点的值都大于等于其左子树中的所有节点的值而小于等于右子树的所有节点的值。
BST 有一个重要性质，就是它的中序遍历结果递增排序。
- 
+ 
基本数据结构：
@@ -325,7 +325,7 @@ private Value get(Node x, Key key) {
当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接指向该节点，使得该节点正确地链接到树中。
- 
+ 
```java
@Override
@@ -354,11 +354,11 @@ private Node put(Node x, Key key, Value value) {
最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。
- 
+ 
在最坏的情况下，树的高度为 N。
- 
+ 
## 4. floor()
@@ -436,7 +436,7 @@ private Node min(Node x) {
令指向最小节点的链接指向最小节点的右子树。
- 
+ 
```java
public void deleteMin() {
@@ -457,7 +457,7 @@ public Node deleteMin(Node x) {
- 如果待删除的节点只有一个子树， 那么只需要让指向待删除节点的链接指向唯一的子树即可；
- 否则，让右子树的最小节点替换该节点。
- 
+ 
```java
public void delete(Key key) {
@@ -520,7 +520,7 @@ private List keys(Node x, Key l, Key h) {
2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
- 
+ 
## 1. 插入操作
@@ -530,11 +530,11 @@ private List keys(Node x, Key l, Key h) {
- 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
- 
+ 
- 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。
- 
+ 
## 2. 性质
@@ -546,7 +546,7 @@ private List keys(Node x, Key l, Key h) {
红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
- 
+ 
红黑树具有以下性质：
@@ -555,7 +555,7 @@ private List keys(Node x, Key l, Key h) {
画红黑树时可以将红链接画平。
- 
+ 
```java
public class RedBlackBST, Value> extends BST {
@@ -575,7 +575,7 @@ public class RedBlackBST, Value> extends BST 
+
```java
public Node rotateLeft(Node h) {
@@ -594,7 +594,7 @@ public Node rotateLeft(Node h) {
进行右旋转是为了转换两个连续的左红链接，这会在之后的插入过程中探讨。
-
+
```java
public Node rotateRight(Node h) {
@@ -613,7 +613,7 @@ public Node rotateRight(Node h) {
一个 4- 节点在红黑树中表现为一个节点的左右子节点都是红色的。分裂 4- 节点除了需要将子节点的颜色由红变黑之外，同时需要将父节点的颜色由黑变红，从 2-3 树的角度看就是将中间节点移到上层节点。
-
+
```java
void flipColors(Node h) {
@@ -631,7 +631,7 @@ void flipColors(Node h) {
- 如果左子节点是红色的，而且左子节点的左子节点也是红色的，进行右旋转；
- 如果左右子节点均为红色的，进行颜色转换。
-
+
```java
@Override
@@ -756,7 +756,7 @@ public class Transaction {
对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 \~N/M。
-
+
## 3. 线性探测法
@@ -765,7 +765,7 @@ public class Transaction {
使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。
-
+
```java
public class LinearProbingHashST implements UnorderedST {
@@ -867,7 +867,7 @@ public void delete(Key key) {
线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~4 位置就是一个聚簇。
-
+
α = N/M，把 α 称为使用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。
diff --git a/notes/计算机操作系统 - 内存管理.md b/notes/计算机操作系统 - 内存管理.md
index 62b6d6f6..ae31fdaf 100644
--- a/notes/计算机操作系统 - 内存管理.md
+++ b/notes/计算机操作系统 - 内存管理.md
@@ -73,7 +73,6 @@
```
-
## 3. 最近未使用
> NRU, Not Recently Used
@@ -89,7 +88,7 @@
NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。
-## 4. 先进先出
+## 4. 先进先出
> FIFO, First In First Out
