怒刷LeetCode的第28天（Java版）

news2024/11/16 22:00:17

目录

第一题

题目来源

题目内容

解决方法

方法一：动态规划

方法二：迭代

方法三：斐波那契数列公式

第二题

题目来源

题目内容

解决方法

方法一：栈

方法二：路径处理类

方法三：正则表达式

方法四：字符串处理

第三题

题目来源

题目内容

解决方法

方法一：动态规划

第一题

题目来源

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阶楼梯的方法数。

具体步骤如下：

  1. 定义常量phi为(1 + sqrt(5)) / 2，定义常量psi为(1 - sqrt(5)) / 2。
  2. 利用斐波那契数列公式，计算第n+1项斐波那契数列的值，即Fn+1 = (phi^(n+1) - psi^(n+1)) / sqrt(5)。
  3. 最后，到达第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<String> 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();
    }
}

思路解析：

  1. 将路径按照"/"分割成多个组件，存储在数组components中。
  2. 遍历components数组，对于每个组件进行如下处理：
    • 如果是"."或空字符串，表示当前目录，忽略即可。
    • 如果是".."，表示上级目录，将栈顶元素弹出。
    • 否则，表示其他目录，将其入栈。
  3. 遍历完所有组件后，将栈中元素依次弹出，拼接成简化后的路径。注意，由于栈是先进后出的，所以需要使用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来实现简化路径。

思路解析：

  1. 使用Paths.get方法将路径字符串转换为Path对象。
  2. 遍历Path对象中的每个组件（即目录名或文件名）。
  3. 如果当前组件不是"."或".."，表示是有效的目录名或文件名，将其拼接到结果字符串中。
  4. 如果当前组件是".."，表示需要返回上级目录，将结果字符串中最后一个目录名删除即可。
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的路径处理类，还可以使用正则表达式来实现简化路径。

思路解析：

  1. 将路径按照"/"分割成多个组件，存储在数组components中。
  2. 遍历components数组，对于每个组件进行如下处理：
    • 如果是"."或空字符串，表示当前目录或空目录，忽略即可。
    • 如果是".."，表示上级目录，将结果字符串中最后一个目录名删除即可。
    • 否则，表示其他目录，将其拼接到结果字符串中。
  3. 遍历完所有组件后，返回结果字符串。注意，如果结果字符串为空，则表示路径为根目录，需要返回"/"。
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的路径处理类、正则表达式，还可以使用字符串处理方法来实现简化路径。

思路解析：

  1. 使用两个指针i和j来遍历路径字符串path。
  2. 当指针i在路径中遇到连续的斜杠时，跳过这些多余的斜杠。
  3. 当指针i遇到非斜杠字符时，将其作为目录名的一部分，存储在StringBuilder对象dirName中。
  4. 检查dirName中的目录名：
    • 如果是"."或空字符串，表示当前目录或空目录，忽略即可。
    • 如果是".."，表示上级目录，将结果字符串中最后一个目录名删除即可。
    • 否则，表示其他目录，将其拼接到结果字符串中。
  5. 继续遍历路径字符串，直到遍历完所有字符。
  6. 返回结果字符串。如果结果字符串为空，则表示路径为根目录，需要返回"/"。
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运行结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1130887.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

生活废品回收系统 JAVA语言设计和实现

生活废品回收系统 JAVA语言设计和实现

目录 一、系统介绍 二、系统下载 三、系统截图 一、系统介绍 基于VueSpringBootMySQL的生活废品回收系统包含资源类型模块、资源品类模块、回收机构模块、回收机构模块、资源销售单模块、资源交易单模块、资源交易单模块&#xff0c;还包含系统自带的用户管理、部门管理、角…
阅读更多...
QGIS003:【04地图导航工具栏】-地图显示、新建视图、时态控制、空间书签操作

QGIS003:【04地图导航工具栏】-地图显示、新建视图、时态控制、空间书签操作

摘要&#xff1a;QGIS地图导航工具栏包括平移地图、居中显示、放大、缩小、全图显示、缩放到选中要素、缩放到图层、缩放到原始分辨率、上一视图、下一视图、新建地图视图、新建3D地图视图、新建空间书签、打开空间书签、时态控制面板、刷新等选项&#xff0c;本文介绍各选项的…
阅读更多...
Linux软件包和进程管理

Linux软件包和进程管理

一、RPM软件包管理 1、RPM管理工具 &#xff08;1&#xff09;RPM是红帽包管理(Redhat Package Manager)的缩写。 由Red Hat公司提出的一种软件包管理标准。 是Linux各发行版中应用最广泛的软件包格式之一&#xff08;还有debian的发行版deb安装包&#xff09;。 RPM功能通过…
阅读更多...
借助文心大模型4.0轻松搞定统计报表

借助文心大模型4.0轻松搞定统计报表

在10月17日的百度世界2023上&#xff0c;文心大模型4.0版本正式发布&#xff01;会上百度董事长李彦宏为我们展示了文心大模型4.0在多轮对话、搜索、地图、商业智能、智能会议、智能视频等方面的强悍。 对此我们保持疑问&#xff0c;那文心大模型4.0真有这么好&#xff1f;我们…
阅读更多...
base_lcoal_planner的LocalPlannerUtil类中getLocalPlan函数详解

base_lcoal_planner的LocalPlannerUtil类中getLocalPlan函数详解

本文主要介绍base_lcoal_planner功能包中LocalPlannerUtil类的getLocalPlan函数&#xff0c;以及其调用的transformGlobalPlan函数、prunePlan函数的相关内容 一、getLocalPlan函数 getLocalPlan函数的源码如下&#xff1a; bool LocalPlannerUtil::getLocalPlan(const geomet…
阅读更多...
网络协议--广播和多播

网络协议--广播和多播

12.1 引言 在第1章中我们提到有三种IP地址&#xff1a;单播地址、广播地址和多播地址。本章将更详细地介绍广播和多播。 广播和多播仅应用于UDP&#xff0c;它们对需将报文同时传往多个接收者的应用来说十分重要。TCP是一个面向连接的协议&#xff0c;它意味着分别运行于两主…
阅读更多...
用 Rust 和 cURL 库制作一个有趣的爬虫

用 Rust 和 cURL 库制作一个有趣的爬虫

目录 一、介绍 二、准备工作 三、代码实现 四、解析 HTML 并提取特定元素示例 总结 本文将介绍如何使用 Rust 编程语言和 cURL 库制作一个有趣的网络爬虫。我们将通过实例代码来展示如何抓取网页内容、处理数据和解析 HTML 结构。同时&#xff0c;还将探讨爬虫技术的原理、…
阅读更多...
语义分割的常用方法和评价准则

语义分割的常用方法和评价准则

常用方法 目前主流的语义分割网络一般是遵循下采样，上采样，特征融合，然后重复该过程，最后经过softmax像素分类。 评价准则 语义分割的评价准则为： 1.像素精度（pixel accuracy）：每一类像素正确分类的个数/ 每一类像素的实际个数。
阅读更多...
Linux C语言开发-D4数据类型

Linux C语言开发-D4数据类型

数据类型分类 bool类型&#xff1a;非零为真&#xff08;true&#xff09;&#xff0c;零为假&#xff08;false&#xff09;&#xff0c;其在<stdbool.h>头文件中 2552的8次方-1 1272的7次方-1 -128的补码是&#xff1a;10000000 一定要注意长度和范围&#xff0c;防…
阅读更多...
【C语言】实现通讯录管理系统

【C语言】实现通讯录管理系统

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家实现通讯录&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 目录 一. 前言二. 通讯录的实现2.1 写出基本框架2.2 制作menu菜单2.3 创建联系人和通讯录结构体2.4 …
阅读更多...
BOA服务器（一）：简介

BOA服务器（一）：简介

在嵌入式设备的管理与交互中&#xff0c;基于Web方式的应用成为目前的主流&#xff0c;这种程序结构也就是大家非常熟悉的B/S结构&#xff0c;即在嵌入式设备上运行一个支持脚本或CGI功能的Web服务器&#xff0c;能够生成动态页面&#xff0c;在用户端只需要通过Web浏览器就可以…
阅读更多...
Itheima-Springboot2【二刷】

Itheima-Springboot2【二刷】

1. Springboot parent和starter区别 parent&#xff1a;开发Springboot项目需要继承spring-boot-starter-parent&#xff0c;其中定义了若干个依赖管理&#xff08;坐标版本号&#xff09;&#xff0c;避免依赖版本冲突&#xff1b;starter&#xff1a;开发Springboot项目需要…
阅读更多...
请解释一下React中的条件渲染（conditional rendering）。

请解释一下React中的条件渲染（conditional rendering）。

聚沙成塔每天进步一点点 ⭐ 专栏简介 前端入门之旅&#xff1a;探索Web开发的奇妙世界 欢迎来到前端入门之旅&#xff01;感兴趣的可以订阅本专栏哦&#xff01;这个专栏是为那些对Web开发感兴趣、刚刚踏入前端领域的朋友们量身打造的。无论你是完全的新手还是有一些基础的开发…
阅读更多...
麒麟KYLINOS桌面操作系统2303上安装tigervnc

麒麟KYLINOS桌面操作系统2303上安装tigervnc

原文链接&#xff1a;麒麟KYLINOS桌面操作系统2303上安装tigervnc hello&#xff0c;大家好啊&#xff0c;今天给大家带来在麒麟桌面操作系统2303上安装tigervnc的文章&#xff0c;本篇文章给大家讲述如何安装并且远程连接使用&#xff0c;后面会给大家更新如何将tigervnc做成桌…
阅读更多...
【ARM Cortex-M 系列 4 番外篇 -- 常用 benchmark 介绍】

【ARM Cortex-M 系列 4 番外篇 -- 常用 benchmark 介绍】

文章目录 1.1 CPU 性能测试 MIPS 计算1.1.1 Cortex-M7 CPI 1.2 benchmark 小节1.3.1 Geekbenck 介绍 1.3 编译参数配置 1.1 CPU 性能测试 MIPS 计算 每秒百万指令数 (MIPS)&#xff1a;在数据压缩测试中&#xff0c;MIPS 每秒测量一次 CPU 执行的低级指令的数量。越高越好&…
阅读更多...
二十、设计模式之迭代器模式

二十、设计模式之迭代器模式

目录 二十、设计模式之迭代器模式能帮我们干什么&#xff1f;主要解决什么问题&#xff1f;优缺点优点缺点&#xff1a; 使用的场景角色 实现迭代器模式定义迭代器容器实现可迭代接口迭代器实现使用 总结 二十、设计模式之迭代器模式 所属类型定义行为型提供一种方法顺序访问一…
阅读更多...
uni-app：解决异步请求返回值问题

uni-app：解决异步请求返回值问题

可以使用 Promise 或者回调函数来处理异步请求的返回值。 方法一&#xff1a; Promise处理异步请求的返回值 使用 Promise 可以将异步请求的结果通过 resolve 和 reject 返回&#xff0c;然后通过 .then() 方法获取成功的结果&#xff0c;通过 .catch() 方法获取错误信息。 …
阅读更多...
ES Nested解释

ES Nested解释

参考博客 参考博客 nested类型是对象数据类型的专用版本&#xff0c;它允许对象数组以可以彼此独立查询的方式进行索引
阅读更多...
React之diff原理

React之diff原理

一、是什么 跟Vue一致&#xff0c;React通过引入Virtual DOM的概念&#xff0c;极大地避免无效的Dom操作&#xff0c;使我们的页面的构建效率提到了极大的提升 而diff算法就是更高效地通过对比新旧Virtual DOM来找出真正的Dom变化之处 传统diff算法通过循环递归对节点进行依…
阅读更多...
为什么亚马逊卖家一定要有独立站？新手低成本快速搭建跨境电商独立站完整图文教程

为什么亚马逊卖家一定要有独立站？新手低成本快速搭建跨境电商独立站完整图文教程

效果展示 翻译助手 一、购买域名 二、购买主机托管 三、搭建独立网站 四、网站装修设计 五、网站迁移 六、补充 前言&#xff1a;为什么亚马逊卖家一定要有独立站&#xff1f; 先来谈谈为什么亚马逊卖家一定得有独立站&#xff0c;从我一些个人经历来看&#xff0c;有独…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023