怒刷LeetCode的第28天（Java版）
目录
第一题
题目来源
题目内容
解决方法
方法一：动态规划
方法二：迭代
方法三：斐波那契数列公式
第二题
题目来源
题目内容
解决方法
方法一：栈
方法二：路径处理类
方法三：正则表达式
方法四：字符串处理
第三题
题目来源
题目内容
解决方法
方法一：动态规划
第一题
题目来源
70. 爬楼梯 - 力扣（LeetCode）
题目内容
解决方法
方法一：动态规划
可以使用动态规划的方法来解决这个问题。假设要爬到第n阶楼梯，那么可以从第n-1阶楼梯爬一步上来，或者从第n-2阶楼梯爬两步上来。因此，到达第n阶楼梯的方法数等于到达第n-1阶楼梯的方法数加上到达第n-2阶楼梯的方法数。
首先初始化前两个楼梯的方法数，即dp[0]=1和dp[1]=1。然后从第3个楼梯开始，通过迭代计算每个楼梯的方法数，直到第n个楼梯。
class Solution {
public int climbStairs(int n) {
if (n <= 1) {
return 1;
}
int[] dp = new int[n + 1];
dp[0] = 1;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
}
复杂度分析：
- 这个算法的时间复杂度是O(n)，其中n是楼梯的阶数。这是因为我们需要计算从第2阶楼梯到第n阶楼梯的方法数，每次计算都需要常数时间。
- 空间复杂度是O(n)，因为我们使用一个大小为n+1的数组来存储每个楼梯的方法数。如果只需要存储前两个楼梯的方法数，空间复杂度可以优化为O(1)。
总结起来，这个算法是相当高效的，可以在合理的时间内解决规模较大的问题。
LeetCode运行结果：
方法二：迭代
除了动态规划，还可以使用迭代的方法来解决这个问题。迭代方法的思路是从前往后计算每个楼梯的方法数，并利用一个变量来保存前两个楼梯的方法数，以便计算当前楼梯的方法数。
class Solution {
public int climbStairs(int n) {
if (n <= 1) {
return 1;
}
int prev1 = 1; // 到达前一个楼梯的方法数
int prev2 = 1; // 到达前两个楼梯的方法数
int current = 0; // 当前楼梯的方法数
for (int i = 2; i <= n; i++) {
current = prev1 + prev2;
prev2 = prev1;
prev1 = current;
}
return current;
}
}
复杂度分析：
- 时间复杂度： 在迭代方法中，我们使用一个循环来计算每个楼梯的方法数，循环执行了n-2次（从第3个楼梯开始计算）。因此，时间复杂度为O(n)。
- 空间复杂度： 在迭代方法中，我们只使用了三个变量：prev1、prev2和current来保存楼梯的方法数。这三个变量的空间占用是常量级别的，与输入规模n无关。因此，空间复杂度为O(1)。
综上所述，迭代方法的时间复杂度为O(n)，空间复杂度为O(1)。
LeetCode运行结果：
方法三：斐波那契数列公式
除了动态规划和迭代，还可以使用斐波那契数列公式的方法来解决爬楼梯问题。
斐波那契数列公式是一个通用的公式，可以用来计算斐波那契数列中任意一项的值。在爬楼梯问题中，我们可以利用斐波那契数列公式来计算到达第n阶楼梯的方法数。
具体步骤如下：
- 定义常量phi为(1 + sqrt(5)) / 2，定义常量psi为(1 - sqrt(5)) / 2。
- 利用斐波那契数列公式，计算第n+1项斐波那契数列的值，即Fn+1 = (phi^(n+1) - psi^(n+1)) / sqrt(5)。
- 最后，到达第n阶楼梯的方法数即为Fn+1。
class Solution {
public int climbStairs(int n) {
double phi = (1 + Math.sqrt(5)) / 2;
double psi = (1 - Math.sqrt(5)) / 2;
double fn = (Math.pow(phi, n + 1) - Math.pow(psi, n + 1)) / Math.sqrt(5);
return (int) Math.round(fn);
}
}
复杂度分析：
- 时间复杂度：O(1)，直接使用斐波那契数列公式计算结果。
- 空间复杂度：O(1)，只需要常量级的额外空间。
LeetCode运行结果：
第二题
题目来源
71. 简化路径 - 力扣（LeetCode）
题目内容
解决方法
方法一：栈
class Solution {
public String simplifyPath(String path) {
Deque stack = new LinkedList<>();
String[] components = path.split("/");
for (String component : components) {
if (component.equals(".") || component.isEmpty()) {
// 当前目录，忽略
} else if (component.equals("..")) {
// 上级目录，弹出栈顶元素
if (!stack.isEmpty()) {
stack.pop();
}
} else {
// 其他目录，入栈
stack.push(component);
}
}
StringBuilder sb = new StringBuilder();
while (!stack.isEmpty()) {
sb.append("/");
sb.append(stack.pollLast());
}
return sb.length() == 0 ? "/" : sb.toString();
}
}
思路解析：
- 将路径按照"/"分割成多个组件，存储在数组components中。
- 遍历components数组，对于每个组件进行如下处理：
- 如果是"."或空字符串，表示当前目录，忽略即可。
- 如果是".."，表示上级目录，将栈顶元素弹出。
- 否则，表示其他目录，将其入栈。
- 遍历完所有组件后，将栈中元素依次弹出，拼接成简化后的路径。注意，由于栈是先进后出的，所以需要使用pollLast方法依次弹出栈顶元素。
复杂度分析：
时间复杂度分析：
- 字符串的split方法的时间复杂度为O(n)，其中n是路径的长度。因为需要遍历整个路径字符串，并根据"/"进行分割。
- 遍历components数组的时间复杂度为O(m)，其中m是路径中的组件数量。最坏情况下，路径中的组件数量与路径长度相等。
- 栈的操作（入栈和出栈）的时间复杂度为O(1)。
综上所述，总的时间复杂度为O(n + m)。
空间复杂度分析：
- components数组的空间复杂度为O(m)，其中m是路径中的组件数量。
- 栈的空间复杂度最坏情况下为O(m)，即路径中每个组件都不同。
- StringBuilder的空间复杂度为O(n)，其中n是路径的长度。
综上所述，总的空间复杂度为O(n + m)。
LeetCode运行结果：
方法二：路径处理类
除了栈，还可以使用Java的路径处理类Path和Paths来实现简化路径。
思路解析：
- 使用Paths.get方法将路径字符串转换为Path对象。
- 遍历Path对象中的每个组件（即目录名或文件名）。
- 如果当前组件不是"."或".."，表示是有效的目录名或文件名，将其拼接到结果字符串中。
- 如果当前组件是".."，表示需要返回上级目录，将结果字符串中最后一个目录名删除即可。
import java.nio.file.Path;
import java.nio.file.Paths;
class Solution {
public String simplifyPath(String path) {
Path p = Paths.get(path);
StringBuilder sb = new StringBuilder();
for (Path component : p) {
if (!component.toString().equals("..") && !component.toString().equals(".")) {
sb.append("/");
sb.append(component.toString());
} else if (component.toString().equals("..")) {
int len = sb.length();
if (len > 1) {
sb.delete(sb.lastIndexOf("/"), len);
}
}
}
return sb.length() == 0 ? "/" : sb.toString();
}
}
复杂度分析：
时间复杂度分析：
- Paths.get方法的时间复杂度为O(n)，其中n是路径的长度。
- 遍历Path对象中的每个组件的时间复杂度为O(m)，其中m是路径中的组件数量。
- StringBuilder的操作的时间复杂度为O(n)，其中n是路径的长度。
综上所述，总的时间复杂度为O(n + m)。
空间复杂度分析：
- Path对象的空间复杂度为O(m)，其中m是路径中的组件数量。
- StringBuilder的空间复杂度为O(n)，其中n是路径的长度。
综上所述，总的空间复杂度为O(n + m)。
LeetCode运行结果：
方法三：正则表达式
除了栈和Java的路径处理类，还可以使用正则表达式来实现简化路径。
思路解析：
- 将路径按照"/"分割成多个组件，存储在数组components中。
- 遍历components数组，对于每个组件进行如下处理：
- 如果是"."或空字符串，表示当前目录或空目录，忽略即可。
- 如果是".."，表示上级目录，将结果字符串中最后一个目录名删除即可。
- 否则，表示其他目录，将其拼接到结果字符串中。
- 遍历完所有组件后，返回结果字符串。注意，如果结果字符串为空，则表示路径为根目录，需要返回"/"。
class Solution {
public String simplifyPath(String path) {
String[] components = path.split("/");
StringBuilder sb = new StringBuilder();
for (String component : components) {
if (component.equals("..")) {
// 返回上级目录，将结果字符串中最后一个目录名删除即可。
int len = sb.length();
if (len > 1) {
sb.delete(sb.lastIndexOf("/"), len);
}
} else if (!component.equals(".") && !component.isEmpty()) {
// 忽略当前目录和空目录，其他目录拼接到结果字符串中。
sb.append("/");
sb.append(component);
}
}
return sb.length() == 0 ? "/" : sb.toString();
}
}
复杂度分析：
时间复杂度分析：
- 字符串的split方法和StringBuilder的append方法都是线性时间复杂度的，所以总时间复杂度为O(n)，其中n是路径的长度。
空间复杂度分析：
- components数组的空间复杂度为O(m)，其中m是路径中的组件数量。
- StringBuilder的空间复杂度为O(n)，其中n是路径的长度。
综上所述，总的空间复杂度为O(n + m)。
LeetCode运行结果：
方法四：字符串处理
除了栈、Java的路径处理类、正则表达式，还可以使用字符串处理方法来实现简化路径。
思路解析：
- 使用两个指针i和j来遍历路径字符串path。
- 当指针i在路径中遇到连续的斜杠时，跳过这些多余的斜杠。
- 当指针i遇到非斜杠字符时，将其作为目录名的一部分，存储在StringBuilder对象dirName中。
- 检查dirName中的目录名：
- 如果是"."或空字符串，表示当前目录或空目录，忽略即可。
- 如果是".."，表示上级目录，将结果字符串中最后一个目录名删除即可。
- 否则，表示其他目录，将其拼接到结果字符串中。
- 继续遍历路径字符串，直到遍历完所有字符。
- 返回结果字符串。如果结果字符串为空，则表示路径为根目录，需要返回"/"。
class Solution {
public String simplifyPath(String path) {
StringBuilder sb = new StringBuilder();
int n = path.length();
int i = 0;
while (i < n) {
// 跳过多余的斜杠
while (i < n && path.charAt(i) == '/') {
i++;
}
// 获取当前目录名
StringBuilder dirName = new StringBuilder();
while (i < n && path.charAt(i) != '/') {
dirName.append(path.charAt(i));
i++;
}
// 处理当前目录名
String name = dirName.toString();
if (name.equals("..")) {
// 返回上级目录，将结果字符串中最后一个目录名删除即可。
int len = sb.length();
if (len > 1) {
sb.delete(sb.lastIndexOf("/"), len);
}
} else if (!name.equals(".") && !name.isEmpty()) {
// 忽略当前目录和空目录，其他目录拼接到结果字符串中。
sb.append("/");
sb.append(name);
}
}
return sb.length() == 0 ? "/" : sb.toString();
}
}复杂度分析：
时间复杂度分析：
- 遍历路径字符串的过程是线性时间复杂度的，所以总时间复杂度为O(n)，其中n是路径的长度。
空间复杂度分析：
- StringBuilder的空间复杂度为O(n)，其中n是路径的长度。
综上所述，总的空间复杂度为O(n)。
LeetCode运行结果：
第三题
题目来源
72. 编辑距离 - 力扣（LeetCode）
题目内容
解决方法
方法一：动态规划
这是一道典型的动态规划问题。
定义状态：dp[i][j]表示将word1的前i个字符转换为word2的前j个字符所需的最少操作数。
状态转移方程：
-
当word1[i] == word2[j]时，不需要进行任何操作，dp[i][j] = dp[i-1][j-1]。
-
当word1[i] != word2[j]时，可以进行三种操作：
- 插入一个字符：dp[i][j] = dp[i][j-1] + 1。
- 删除一个字符：dp[i][j] = dp[i-1][j] + 1。
- 替换一个字符：dp[i][j] = dp[i-1][j-1] + 1。
最终结果为dp[m][n]，其中m和n分别是word1和word2的长度。
class Solution {
public int minDistance(String word1, String word2) {
int m = word1.length();
int n = word2.length();
// 创建动态规划数组
int[][] dp = new int[m+1][n+1];
// 初始化边界条件
for (int i = 0; i <= m; i++) {
dp[i][0] = i;
}
for (int j = 0; j <= n; j++) {
dp[0][j] = j;
}
// 动态规划求解
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (word1.charAt(i-1) == word2.charAt(j-1)) {
dp[i][j] = dp[i-1][j-1];
} else {
dp[i][j] = Math.min(dp[i-1][j-1], Math.min(dp[i][j-1], dp[i-1][j])) + 1;
}
}
}
return dp[m][n];
}
}复杂度分析：
该算法的时间复杂度为O(m*n)，其中m和n分别是word1和word2的长度。
在动态规划求解过程中，需要填充一个大小为(m+1)(n+1)的二维数组dp。对于每个位置(i, j)，都需要通过比较word1.charAt(i-1)和word2.charAt(j-1)来确定操作的类型。因此，总共需要进行mn次比较和计算。
空间复杂度方面，需要额外开辟一个大小为(m+1)(n+1)的二维数组dp来保存中间结果。因此，空间复杂度也为O(mn)。
综上所述，该算法的时间复杂度和空间复杂度均为O(m*n)。
LeetCode运行结果：
