力扣热题 100：动态规划专题经典题解析

news2025/3/13 9:42:50

系列文章目录

力扣热题 100：哈希专题三道题详细解析(JAVA)
力扣热题 100：双指针专题四道题详细解析(JAVA)
力扣热题 100：滑动窗口专题两道题详细解析（JAVA）
力扣热题 100：子串专题三道题详细解析(JAVA)
力扣热题 100：普通数组专题五道题详细解析(JAVA)
力扣热题 100：矩阵专题四道题详细解析（JAVA）
力扣热题 100：链表专题经典题解析(前7道)
力扣热题 100：链表专题经典题解析（后7道）
力扣热题 100：二叉树专题经典题解析（前8道）
力扣热题 100：二叉树专题进阶题解析（后7道）
力扣热题 100：图论专题经典题解析
力扣热题 100：回溯专题经典题解析
力扣热题 100：二分查找专题经典题解析
力扣热题 100：栈专题经典题解析
力扣热题 100：堆专题经典题解析
力扣热题 100：贪心算法专题经典题解析
力扣热题 100：动态规划专题经典题解析
力扣热题 100：多维动态规划专题经典题解析
力扣热题 100：技巧专题经典题解析

文章目录

      • 系列文章目录
    • 一、爬楼梯（题目 70）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 二、杨辉三角（题目 118）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 三、打家劫舍（题目 198）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 四、完全平方数（题目 279）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 五、零钱兑换（题目 322）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 六、单词拆分（题目 139）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 七、最长递增子序列（题目 300）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 八、乘积最大子数组（题目 152）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 九、分割等和子集（题目 416）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析
    • 十、最长有效括号（题目 32）
      • 1. 题目描述
      • 2. 示例
      • 3. 解题思路
      • 4. 代码实现（Java）
      • 5. 复杂度分析

在力扣（LeetCode）平台上，动态规划相关的题目是算法面试和练习中的重要部分。今天，我们就来详细解析动态规划专题中的几道经典题目，帮助大家更好地理解解题思路和技巧。

一、爬楼梯（题目 70）

1. 题目描述

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶？

2. 示例

示例 1：

输入：n = 2

输出：2

解释：有两种方法：1 阶 + 1 阶 或 2 阶。

示例 2：

输入：n = 3

输出：3

解释：有三种方法：1+1+1, 1+2, 2+1。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录到达每个台阶的方法数。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示到达第 i 阶的方法数。
  2. 初始化 dp[0] = 1（到达第 0 阶的方法数为 1，即不动）和 dp[1] = 1（到达第 1 阶的方法数为 1，即爬 1 阶）。
  3. 对于每个台阶 i，其方法数等于到达前一阶和前两阶的方法数之和，即 dp[i] = dp[i-1] + dp[i-2]。

4. 代码实现（Java）

public class Solution {
    public int climbStairs(int n) {
        if (n == 0) return 0;
        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];
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n)，其中 n 是台阶数。我们需要遍历从 2 到 n 的所有台阶。
  • 空间复杂度 ：O(n)，需要使用数组存储每个台阶的方法数。可以优化为 O(1) 空间，只保留前两个状态。

二、杨辉三角（题目 118）

1. 题目描述

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

2. 示例

示例 1：

输入：numRows = 5

输出：[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来生成杨辉三角的每一行。具体步骤如下：

  1. 初始化一个二维列表 result，用于存储杨辉三角的每一行。
  2. 对于每一行 i，初始化一个长度为 i+1 的列表，并将首尾元素设为 1。
  3. 对于中间的元素，其值等于上一行对应位置的元素和前一个元素之和。

4. 代码实现（Java）

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> result = new ArrayList<>();
        for (int i = 0; i < numRows; i++) {
            List<Integer> row = new ArrayList<>();
            for (int j = 0; j <= i; j++) {
                if (j == 0 || j == i) {
                    row.add(1);
                } else {
                    row.add(result.get(i - 1).get(j - 1) + result.get(i - 1).get(j));
                }
            }
            result.add(row);
        }
        return result;
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(numRows^2)，需要生成每一行的每个元素。
  • 空间复杂度 ：O(numRows^2)，需要存储杨辉三角的所有元素。

三、打家劫舍（题目 198）

1. 题目描述

给定一个整数数组 nums 表示每个房子中的金额，相邻的房子不能同时被抢劫。求能抢劫到的最大金额。

2. 示例

示例 1：

输入：nums = [1, 2, 3, 1]

输出：4

解释：抢劫第 2 个和第 3 个房子，金额为 2 + 3 = 5。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录每个房子能抢劫到的最大金额。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示前 i 个房子能抢劫到的最大金额。
  2. 初始化 dp[0] = nums[0] 和 dp[1] = Math.max(nums[0], nums[1])。
  3. 对于每个房子 i，其最大金额等于 Math.max(dp[i-1], dp[i-2] + nums[i])。

4. 代码实现（Java）

public class Solution {
    public int rob(int[] nums) {
        if (nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[nums.length - 1];
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n)，其中 n 是房子的数量。需要遍历每个房子一次。
  • 空间复杂度 ：O(n)，需要使用数组存储每个房子的最大金额。可以优化为 O(1) 空间，只保留前两个状态。

四、完全平方数（题目 279）

1. 题目描述

给定一个正整数 n，找到最少数量的完全平方数的和等于 n。

2. 示例

示例 1：

输入：n = 12

输出：3

解释：4 + 4 + 4 = 12。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录每个数的最少完全平方数数量。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示和为 i 的最少完全平方数数量。
  2. 初始化 dp[0] = 0。
  3. 对于每个数 i，遍历所有可能的完全平方数 j，更新 dp[i] = Math.min(dp[i], dp[i - j] + 1)。

4. 代码实现（Java）

public class Solution {
    public int numSquares(int n) {
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j * j <= i; j++) {
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
            }
        }
        return dp[n];
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n * sqrt(n))，需要遍历每个数和其可能的完全平方数。
  • 空间复杂度 ：O(n)，需要使用数组存储每个数的最少数量。

五、零钱兑换（题目 322）

1. 题目描述

给定不同面额的硬币和一个总金额，求凑成总金额所需的最少硬币数。如果无法凑成，返回 -1。

2. 示例

示例 1：

输入：coins = [1, 2, 5], amount = 11

输出：3

解释：5 + 5 + 1 = 11。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录每个金额的最少硬币数。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示金额为 i 时的最少硬币数。
  2. 初始化 dp[0] = 0，其余为 Integer.MAX_VALUE。
  3. 对于每个金额 i，遍历所有硬币，更新 dp[i] = Math.min(dp[i], dp[i - coin] + 1)。

4. 代码实现（Java）

public class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int i = 1; i <= amount; i++) {
            for (int coin : coins) {
                if (coin <= i && dp[i - coin] != Integer.MAX_VALUE) {
                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
                }
            }
        }
        return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(amount * coins.length)，需要遍历每个金额和每个硬币。
  • 空间复杂度 ：O(amount)，需要使用数组存储每个金额的最少硬币数。

六、单词拆分（题目 139）

1. 题目描述

给定一个字符串 s 和一个单词集合 wordDict，判断 s 是否可以被拆分成一个或多个在单词集合中出现的单词。

2. 示例

示例 1：

输入：s = "leetcode", wordDict = ["leet", "code"]

输出：true

解释："leetcode" 可以被拆分成 "leet code"。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录字符串的每个位置是否可以被拆分。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示字符串的前 i 个字符是否可以被拆分。
  2. 初始化 dp[0] = true（空字符串可以被拆分）。
  3. 对于每个位置 i，遍历所有可能的单词长度，检查是否可以拆分。

4. 代码实现（Java）

public class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> wordSet = new HashSet<>(wordDict);
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 0; j < i; j++) {
                if (dp[j] && wordSet.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n^2)，其中 n 是字符串的长度。需要遍历每个位置和每个可能的单词长度。
  • 空间复杂度 ：O(n)，需要使用数组存储每个位置的拆分状态。

七、最长递增子序列（题目 300）

1. 题目描述

给定一个整数数组 nums，找到最长递增子序列的长度。

2. 示例

示例 1：

输入：nums = [10, 9, 2, 5, 3, 7, 101, 18]

输出：4

解释：最长递增子序列是 [2, 3, 7, 101]。

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录每个位置的最长递增子序列长度。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示以 nums[i] 结尾的最长递增子序列长度。
  2. 初始化 dp 数组为全 1。
  3. 对于每个位置 i，遍历其前面的所有位置 j，如果 nums[i] > nums[j]，则 dp[i] = Math.max(dp[i], dp[j] + 1)。

4. 代码实现（Java）

public class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums.length == 0) return 0;
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);
        int max = 1;
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            max = Math.max(max, dp[i]);
        }
        return max;
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n^2)，其中 n 是数组的长度。需要遍历每个位置和其前面的所有位置。
  • 空间复杂度 ：O(n)，需要使用数组存储每个位置的最长递增子序列长度。可以优化为 O(n log n) 时间复杂度，使用二分查找。

八、乘积最大子数组（题目 152）

1. 题目描述

给定一个整数数组 nums，找到一个子数组，使得该子数组的乘积最大。返回这个最大乘积。

2. 示例

示例 1：

输入：nums = [2, 3, -2, 4]

输出：6

解释：子数组 [2, 3] 的乘积为 6。

3. 解题思路

这道题主要考察动态规划的应用。由于乘积可能为负数，我们需要同时记录最大值和最小值。具体步骤如下：

  1. 定义两个数组 maxDp 和 minDp，分别记录以当前元素结尾的最大乘积和最小乘积。
  2. 初始化 maxDp[0] = nums[0] 和 minDp[0] = nums[0]。
  3. 对于每个元素 i，计算 maxDp[i] = Math.max(nums[i], Math.max(maxDp[i-1] * nums[i], minDp[i-1] * nums[i])) 和 minDp[i] = Math.min(nums[i], Math.min(maxDp[i-1] * nums[i], minDp[i-1] * nums[i]))。

4. 代码实现（Java）

public class Solution {
    public int maxProduct(int[] nums) {
        if (nums.length == 0) return 0;
        int[] maxDp = new int[nums.length];
        int[] minDp = new int[nums.length];
        maxDp[0] = nums[0];
        minDp[0] = nums[0];
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            maxDp[i] = Math.max(nums[i], Math.max(maxDp[i - 1] * nums[i], minDp[i - 1] * nums[i]));
            minDp[i] = Math.min(nums[i], Math.min(maxDp[i - 1] * nums[i], minDp[i - 1] * nums[i]));
            max = Math.max(max, maxDp[i]);
        }
        return max;
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n)，其中 n 是数组的长度。需要遍历每个元素一次。
  • 空间复杂度 ：O(n)，需要使用两个数组存储最大值和最小值。可以优化为 O(1) 空间，只保留前一个状态。

九、分割等和子集（题目 416）

1. 题目描述

给定一个非空整数数组 nums，判断是否可以将其划分为两个子集，使得两个子集的元素和相等。

2. 示例

示例 1：

输入：nums = [1, 5, 11, 5]

输出：true

解释：可以划分为 [1, 5, 5] 和 [11]。

3. 解题思路

这道题主要考察动态规划的应用。我们可以将问题转化为背包问题，判断是否存在一个子集的和等于总和的一半。具体步骤如下：

  1. 计算数组的总和 sum，如果 sum 是奇数，则无法分割。
  2. 定义一个数组 dp，其中 dp[i] 表示是否可以达到和为 i 的子集。
  3. 初始化 dp[0] = true。
  4. 遍历每个数，更新 dp 数组。

4. 代码实现（Java）

public class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum % 2 != 0) {
            return false;
        }
        int target = sum / 2;
        boolean[] dp = new boolean[target + 1];
        dp[0] = true;
        for (int num : nums) {
            for (int i = target; i >= num; i--) {
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[target];
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n * target)，其中 n 是数组的长度，target 是总和的一半。
  • 空间复杂度 ：O(target)，需要使用数组存储是否可以达到每个和。

十、最长有效括号（题目 32）

1. 题目描述

给定一个只包含 '(' 和 ')' 的字符串，找到最长的有效括号子串的长度。

2. 示例

示例 1：

输入：s = "(()"

输出：2

解释：最长的有效括号子串是 "()"

3. 解题思路

这道题主要考察动态规划的应用。我们可以使用动态规划来记录每个位置的最长有效括号长度。具体步骤如下：

  1. 定义一个数组 dp，其中 dp[i] 表示以 i 结尾的最长有效括号子串的长度。
  2. 初始化 dp 数组为全 0。
  3. 遍历字符串，当遇到 ')' 时，检查前面的字符是否为 '(' 或者前面的子串是否有效，更新 dp[i]。

4. 代码实现（Java）

public class Solution {
    public int longestValidParentheses(String s) {
        int maxLen = 0;
        int[] dp = new int[s.length()];
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i) == ')') {
                if (s.charAt(i - 1) == '(') {
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
                } else if (i - dp[i - 1] - 1 >= 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
                    dp[i] = dp[i - 1] + 2 + (i - dp[i - 1] - 2 >= 0 ? dp[i - dp[i - 1] - 2] : 0);
                }
                maxLen = Math.max(maxLen, dp[i]);
            }
        }
        return maxLen;
    }
}

5. 复杂度分析

  • 时间复杂度 ：O(n)，其中 n 是字符串的长度。需要遍历每个字符一次。
  • 空间复杂度 ：O(n)，需要使用数组存储每个位置的最长有效括号长度。

以上就是力扣热题 100 中与动态规划相关的经典题目的详细解析，希望对大家有所帮助。在实际刷题过程中，建议大家多动手实践，理解解题思路的本质，这样才能更好地应对各种算法问题。在这里插入图片描述

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

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

相关文章

变量赋值汇编

变量赋值汇编

一、核心概念 寄存器&#xff1a;CPU内部的高速存储单元&#xff08;如EAX、EBX、x86中的RAX、ARM中的R0等&#xff09; 内存地址&#xff1a;变量存储在内存中的位置&#xff08;如 0x1000&#xff09; 指令&#xff1a;操作寄存器和内存的命令&#xff08;如 MOV, STR, LDR…
阅读更多...
页面白屏出现的原因

页面白屏出现的原因

&#x1f916; 作者简介&#xff1a;水煮白菜王&#xff0c;一位前端劝退师 &#x1f47b; &#x1f440; 文章专栏&#xff1a; 前端专栏 &#xff0c;记录一下平时在博客写作中&#xff0c;总结出的一些开发技巧和知识归纳总结✍。 感谢支持&#x1f495;&#x1f495;&#…
阅读更多...
【大模型统一集成项目】让 AI 聊天更丝滑：WebSocket 实现流式对话！

【大模型统一集成项目】让 AI 聊天更丝滑：WebSocket 实现流式对话！

&#x1f31f; 在这系列文章中&#xff0c;我们将一起探索如何搭建一个支持大模型集成项目 NexLM 的开发过程&#xff0c;从 架构设计 到 代码实战&#xff0c;逐步搭建一个支持 多种大模型&#xff08;GPT-4、DeepSeek 等&#xff09; 的 一站式大模型集成与管理平台&#xff…
阅读更多...
【2025】Electron Git Desktop 实战一（上）（架构及首页设计开发）

【2025】Electron Git Desktop 实战一（上）（架构及首页设计开发）

源代码仓库&#xff1a; Github仓库【electron_git】 Commit &#xff1a; bb40040 Github Desktop 页面分析 本节目标&#xff1a; 1、实现类似Github Desktop的「空仓库」提示页 2、添加本地仓库逻辑编写从 Github Desktop 我们看到 他的 主要页面分为三个区域 Head头部区域…
阅读更多...
14 | fastgo 三层架构设计

14 | fastgo 三层架构设计

提示&#xff1a; 所有体系课见专栏&#xff1a;Go 项目开发极速入门实战课&#xff1b; 在实现业务代码之前&#xff0c;还需要先设计一个合理的软件架构。一个好的软件架构不仅可以大大提高项目的迭代速度&#xff0c;还可以降低项目的阅读和维护难度。目前&#xff0c;行业中…
阅读更多...
【机器学习-基础知识】统计和贝叶斯推断

【机器学习-基础知识】统计和贝叶斯推断

1. 概率论基本概念回顾 1. 概率分布 定义： 概率分布（Probability Distribution）指的是随机变量所有可能取值及其对应概率的集合。它描述了一个随机变量可能取的所有值以及每个值被取到的概率。 对于离散型随机变量，使用概率质量函数来描述。对于连续型随机变量，使用概率…
阅读更多...
面向对象Demo01

面向对象Demo01

面向对象 什么是面向对象 回顾方法的定义 package oop; ​ import java.io.IOException; ​ public class Demo01 {public static void main(String[] args) {}//public String sayHello() {return "hello, world!";}public void sayHi() {return;}public int max(i…
阅读更多...
C++设计模式-抽象工厂模式：从原理、适用场景、使用方法，常见问题和解决方案深度解析

C++设计模式-抽象工厂模式：从原理、适用场景、使用方法，常见问题和解决方案深度解析

一、模式基本概念 1.1 定义与核心思想 抽象工厂模式&#xff08;Abstract Factory Pattern&#xff09;是创建型设计模式的集大成者&#xff0c;它通过提供统一的接口来创建多个相互关联或依赖的对象族&#xff0c;而无需指定具体类。其核心思想体现在两个维度&#xff1a; …
阅读更多...
solana区块链地址生成

solana区块链地址生成

solana官网地址&#xff1a;https://solana.com 先引入相关依赖solana/web3.js;bip39;ethereumjs/wallet 生成助记词 const mnemonic bip39.generateMnemonic(); 生成种子 const seed bip39.mnemonicToSeedSync(mnemonic); 生成密钥对 const root hdkey.EthereumHDKey.from…
阅读更多...
基于python的升级队列加速决策

基于python的升级队列加速决策

a-f大等级是3级 a-c建筑每升1级分别需要8天 d-f建筑每升1级分别需要10天 目前以下建筑队列正在从0级升至1级 建筑A升级需要7天05&#xff1a;16&#xff1a;20 建筑b升级需要06&#xff1a;06&#xff1a;54 建筑c升级需要00&#xff1a;37&#xff1a;00 建筑d升级需要…
阅读更多...
Ragflow技术栈分析及二次开发指南

Ragflow技术栈分析及二次开发指南

Ragflow是目前团队化部署大模型+RAG的优质方案，不过其仍不适合直接部署使用，本文将从实际使用的角度，对其进行二次开发。 1. Ragflow 存在问题 Ragflow 开源仓库地址：https://github.com/infiniflow/ragflow Ragflow 当前版本： v0.17.0 Ragflow 目前主要存在以下问题： …
阅读更多...
1.7 双指针专题：三数之和（medium）

1.7 双指针专题：三数之和（medium）

1.题目链接 15. 三数之和 - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/3sum/submissions/609626561/ 2.题目描述 给你⼀个整数数组 nums &#xff0c;判断是否存在三元组 [nums[i], nums[j], nums[k]] 满⾜ i ! j、i ! k 且 j ! k &#xff0c;同时…
阅读更多...
【JavaEE】Spring Boot配置文件

【JavaEE】Spring Boot配置文件

目录 一、Spring Boot配置文件简介二、properties 配置⽂件说明2.1 properties 基本语法2.2 value("${}")读取配置⽂件 三、yml 配置文件说明3.1 yml 基本格式3.2 yml 配置数据类型 及 读取3.3 yml配置对象及读取ConfigurationProperties(prefix "")3.4 配…
阅读更多...
行为模式---策略模式

行为模式---策略模式

概念 策略模式是一种行为设计摸是&#xff0c;它的核心思想是将一些列的算法封装成独立的对象&#xff0c;并使它们可以相互替换&#xff0c;通过上下文进行调用。 策略模式通过算法抽象为独立的策略类&#xff0c;客户端可以根据自身需求选择不同的策略类来完成任务、这种方…
阅读更多...
Word 小黑第15套

Word 小黑第15套

对应大猫16 修改样式集 导航 -查找 第一章标题不显示 再选中文字 点击标题一 修改标题格式 格式 -段落 -换行和分页 勾选与下段同页 添加脚注 &#xff08;脚注默认位于底部 &#xff09;在脚注插入文档属性&#xff1a; -插入 -文档部件 -域 类别选择文档信息&#xff0c;域…
阅读更多...
OSPF：虚链路

OSPF：虚链路

一、虚链路概念 在OSPF中&#xff0c;虚链路&#xff08;Virtual Link&#xff09; 是一种逻辑连接&#xff0c;用于解决因网络设计或扩展导致的区域无法直接连接到骨干区域&#xff08;Area 0&#xff09;的问题。它是通过中间区域&#xff08;Transit Area&#xff09;在两个…
阅读更多...
网络安全事件响应--应急响应（windows）

网络安全事件响应--应急响应（windows）

应用系统日志 Windows主要有以下三类日志记录系统事件&#xff1a;应用程序日志、系统日志和安全日志。 系统和应用程序日志存储着故障排除信息&#xff0c;对于系统管理员更为有用。安全日志记录着事件审计信息&#xff0c;包括用户验证&#xff08;登录、远程访问等&#x…
阅读更多...
DataEase：一款国产开源数据可视化分析工具

DataEase：一款国产开源数据可视化分析工具

DataEase 是由飞致云开发的一款基于 Web 的数据可视化 BI 工具&#xff0c;支持丰富的数据源连接&#xff0c;能够通过拖拉拽方式快速制作图表&#xff0c;帮助用户快速分析业务数据并洞察其趋势&#xff0c;为企业的业务改进与优化提供支持。 DataEase 的优势在于&#xff1a;…
阅读更多...
RTK与RTD基础原理

RTK与RTD基础原理

(文中的部分图片是摘自其他博主的文章&#xff0c;由于比较久&#xff0c;忘记原本链接了&#xff0c;侵删) GPS定位原理 卫星自身有自己的星历与原子钟&#xff0c;因此卫星知道自身准确的空间坐标与时间。因为每个卫星都有原子钟&#xff0c;因此每颗卫星的时间基本上都是相…
阅读更多...
Python读取显示Latex的公式文档，Python加载显示markdown文件。

Python读取显示Latex的公式文档，Python加载显示markdown文件。

平时用LLM大语言模型去解释文献里面的公式含义直接复制的格式word看不懂&#xff0c;基于这个web可以正常加载显示。 下面是读取的效果展示&#xff1a;下面程序保存为stl_read.py然后运行下面指令。 streamlit run stl_read.pyimport streamlit as st import base64 import …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023