Offer必备算法37_记忆化搜索_五道力扣题详解（由易到难）

2024-05-10 02:12
文章标签 算法 详解 搜索 37 必备 记忆 offer 由易到难 五道 力扣题

本文主要是介绍Offer必备算法37_记忆化搜索_五道力扣题详解（由易到难），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

记忆化搜索概念和使用场景

①力扣509. 斐波那契数

解析代码1_循环

解析代码2_暴搜递归

解析代码3_记忆化搜索

解析代码4_动态规划

②力扣62. 不同路径

解析代码1_暴搜递归（超时）

解析代码2_记忆化搜索

解析代码3_动态规划

③力扣300. 最长递增子序列

解析代码1_爆搜递归（超时）

解析代码2_记忆化搜索

解析代码3_动态规划

④力扣375. 猜数字大小 II

解析代码1_爆搜递归（超时）

解析代码2_记忆化搜索

⑤力扣329. 矩阵中的最长递增路径

解析代码1_爆搜递归（超时）

解析代码2_记忆化搜索

本篇完。

记忆化搜索概念和使用场景

记忆化搜索是一种典型的空间换时间的思想，可以看成带备忘录的爆搜递归。

        搜索的低效在于没有能够很好地处理重叠子问题。在搜索过程中，会有很多重复计算，如果我们能记录一些状态的答案，就可以减少重复搜索量。动态规划虽然比较好地处理了重叠子问题，但是在有些拓扑关系比较复杂的题目面前，又显得无奈。记忆化搜索正是在这样的情况下产生的，它采用搜索的形式和动态规划中递推的思想将这两种方法有机地综合在一起，扬长避短，简单实用，在信息学中有着重要的作用。

        根据记忆化搜索的思想，它是解决重复计算，而不是重复生成，也就是说，这些搜索必须是在搜索扩展路径的过程中分步计算的题目，也就是“搜索答案与路径相关″的题目，而不能是搜索一个路径之后才能进行计算的题目，必须要分步计算，并且搜索过程中，一个搜索结果必须可以建立在同类型问题的结果上，也就是类似于动态规划解决的那种。

        记忆化搜索的典型应用场景是可能经过不同路径转移到相同状态的dfs问题。更明确地说，当我们需要在有层次结构的图（不是树，即当前层的不同节点可能转移到下一层的相同节点）中自上而下地进行dfs搜索时，大概率我们都可以通过记忆化搜索的技巧降低时间复杂度。

动态规划和记忆化搜索都是在爆搜的基础上优化。《算法导论》里也把记忆化搜索看成动态规划。

①力扣509. 斐波那契数

509. 斐波那契数

难度 简单

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

提示：

  • 0 <= n <= 30
class Solution {
public:int fib(int n) {}
};

解析代码1_循环

求斐波那契数是很经典的一道题，有多种解法。

        下面会从递归解法得出记忆化搜索解法，在得出动态规划解法，循环的解法也可以看作动态规划的状态压缩，完成闭环。

class Solution {
public:int fib(int n) {if (n < 2)return n;int fib1 = 0, fib2 = 0, ret = 1;for (int i = 2; i <= n; ++i){fib1 = fib2;fib2 = ret;ret = fib1 + fib2;}return ret;}
};

解析代码2_暴搜递归

暴搜递归：

  • 递归含义：给 dfs 一个使命，给它一个数 n ，返回第 n 个斐波那契数的值。
  • 函数体：斐波那契数的递推公式。
  • 递归出口：当 n == 0 或者 n == 1 时，不用套公式。
class Solution {
public:int fib(int n) {return dfs(n);}int dfs(int n){if(n <= 1)return n;return dfs(n - 1) + dfs(n - 2);}
};

解析代码3_记忆化搜索

记忆化搜索：

  • 在递归的基础上加上一个备忘录（所以记忆化搜索也叫带备忘录的递归）。
  • 每次进入递归的时候，去备忘录里面看看。
  • 每次返回的时候，将结果加入到备忘录里面。
class Solution {int memo[31];
public:int fib(int n) {memset(memo, -1, sizeof(memo));return dfs(n);}int dfs(int n){if(n <= 1)return n;if(memo[n] != -1)return memo[n];memo[n] = dfs(n - 1) + dfs(n - 2);return memo[n];}
};

解析代码4_动态规划

动态规划已经写过很多题了，这里根据记忆化搜索得出动态规划的解法：

  • 递归含义：状态表示
  • 函数体：状态转移方程
  • 递归出口：初始化
  • 填表顺序：填备忘录的顺序
  • 返回值：备忘录的值

        可以看出都是类似的，因为两者本质都是一样的，都是在爆搜的基础上优化。《算法导论》里也把记忆化搜索看成动态规划。

        所以很多时候都可以把爆搜递归的代码改成记忆化搜索，再改成动态规划，不过爆搜改记忆化搜索已经完成时间的优化了，没太多必要改成动态规划了。

class Solution {
public:int fib(int n) {if(n == 0)return 0;vector<int> dp(n + 1);dp[1] = 1;for(int i = 2; i <= n; ++i){dp[i] = dp[i - 1] + dp[i - 2];}return dp[n];}
};

②力扣62. 不同路径

62. 不同路径

难度 中等

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

  • 1 <= m, n <= 100
  • 题目数据保证答案小于等于 2 * 10^9
class Solution {
public:int uniquePaths(int m, int n) {}
};

解析代码1_暴搜递归（超时）

  • 递归含义：给 dfs 一个下标，返回从 [0, 0] 位置走到 [i, j] 位置一共有多少种方法。
  • 函数体：只要知道到达上面位置的方法数以及到达左边位置的方法数，然后累加起来即可。
  • 递归出口：当下标越界的时候返回 0 ，当位于起点的时候，返回 1 。
class Solution {
public:int uniquePaths(int m, int n) {return dfs(m, n);}int dfs(int sr, int sc){if(sr == 0 || sc == 0)return 0;if(sr == 1 && sc == 1)return 1;return dfs(sr - 1, sc) + dfs(sr, sc - 1);}
};

解析代码2_记忆化搜索

记忆化搜索解法：

  • 加上一个备忘录。
  • 每次进入递归的时候，去备忘录里面看看。
  • 每次返回的时候，将结果加入到备忘录里面。
class Solution {
public:int uniquePaths(int m, int n) {vector<vector<int>> memo(m + 1, vector<int>(n + 1));return dfs(m, n, memo);}int dfs(int sr, int sc, vector<vector<int>>& memo){if(sr == 0 || sc == 0)return 0;if(sr == 1 && sc == 1)return 1;if(memo[sr][sc] != 0)return memo[sr][sc];memo[sr][sc] = dfs(sr - 1, sc, memo) + dfs(sr, sc - 1, memo);return memo[sr][sc];}
};

解析代码3_动态规划

根据记忆化搜索得出动态规划的解法：

  • 递归含义：状态表示
  • 函数体：状态转移方程
  • 递归出口：初始化
  • 填表顺序：填备忘录的顺序
  • 返回值：备忘录的值
class Solution {
public:int uniquePaths(int m, int n) {vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));dp[1][1] = 1;for(int i = 1; i <= m; ++i){for(int j = 1; j <= n; ++j){if(i == 1 && j == 1)continue;dp[i][j] = dp[i - 1][j] + dp[i][j - 1];}}return dp[m][n];}
};

③力扣300. 最长递增子序列

300. 最长递增子序列

难度 中等

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

  • 1 <= nums.length <= 2500
  • -10^4 <= nums[i] <= 10^4

进阶：

  • 你能将算法的时间复杂度降低到 O(n log(n)) 吗?
class Solution {
public:int lengthOfLIS(vector<int>& nums) {}
};

解析代码1_爆搜递归（超时）

  • 递归含义：给 dfs 一个数 i ，返回以 i 位置为起点的最长增子序列的长度。
  • 函数体：遍历 i 后面的所有位置，看谁能加到 i 这个元素的后面。统计所有情况下的最大值。
  • 递归出口：因为是判断之后再进入递归的，因此没有出口。
class Solution {
public:int lengthOfLIS(vector<int>& nums) {int sz = nums.size(), ret = 1;for(int i = 0; i < sz; ++i){ret = max(ret, dfs(i, nums));}return ret;}int dfs(int pos, vector<int>& nums){int sz = nums.size(), ret = 1;for(int i = pos + 1; i < sz; ++i){if(nums[i] > nums[pos])ret = max(ret, dfs(i, nums) + 1);}return ret;}
};

解析代码2_记忆化搜索

记忆化搜索解法：

  • 加上一个备忘录。
  • 每次进入递归的时候，去备忘录里面看看。
  • 每次返回的时候，将结果加入到备忘录里面。
class Solution {
public:int lengthOfLIS(vector<int>& nums) {int sz = nums.size(), ret = 1;vector<int> memo(sz);for(int i = 0; i < sz; ++i){ret = max(ret, dfs(i, nums, memo));}return ret;}int dfs(int pos, vector<int>& nums, vector<int>& memo){if(memo[pos] != 0)return memo[pos];int sz = nums.size(), ret = 1;for(int i = pos + 1; i < sz; ++i){if(nums[i] > nums[pos])ret = max(ret, dfs(i, nums, memo) + 1);}memo[pos] = ret;return ret;}
};

解析代码3_动态规划

根据记忆化搜索得出动态规划的解法：

  • 递归含义：状态表示
  • 函数体：状态转移方程
  • 递归出口：初始化
  • 填表顺序：填备忘录的顺序
  • 返回值：备忘录的值

        注意这里填表顺序有点不一样，因为记忆化搜索填pos位置的值的时候，依赖的是pos后面的值，所以动态规划解法的代码，填表顺序是从后往前填表。

class Solution {
public:int lengthOfLIS(vector<int>& nums) {int sz = nums.size(), ret = 1;vector<int> dp(sz, 1);for(int i = sz - 2; i >= 0; --i){for(int j = i + 1; j < sz; ++j){if(nums[j] > nums[i])dp[i] = max(dp[i], dp[j] + 1);}ret = max(ret, dp[i]);}return ret;}
};

④力扣375. 猜数字大小 II

375. 猜数字大小 II

难度 中等

我们正在玩一个猜数游戏，游戏规则如下：

  1. 我从 1 到 n 之间选择一个数字。
  2. 你来猜我选了哪个数字。
  3. 如果你猜到正确的数字，就会 赢得游戏 。
  4. 如果你猜错了，那么我会告诉你，我选的数字比你的 更大或者更小 ，并且你需要继续猜数。
  5. 每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。如果你花光了钱，就会 输掉游戏 。

给你一个特定的数字 n ，返回能够 确保你获胜 的最小现金数，不管我选择那个数字 。

示例 1：

输入：n = 10
输出：16
解释：制胜策略如下：
- 数字范围是 [1,10] 。你先猜测数字为 7 。- 如果这是我选中的数字，你的总费用为 $0 。否则，你需要支付 $7 。- 如果我的数字更大，则下一步需要猜测的数字范围是 [8,10] 。你可以猜测数字为 9 。- 如果这是我选中的数字，你的总费用为 $7 。否则，你需要支付 $9 。- 如果我的数字更大，那么这个数字一定是 10 。你猜测数字为 10 并赢得游戏，总费用为 $7 + $9 = $16 。- 如果我的数字更小，那么这个数字一定是 8 。你猜测数字为 8 并赢得游戏，总费用为 $7 + $9 = $16 。- 如果我的数字更小，则下一步需要猜测的数字范围是 [1,6] 。你可以猜测数字为 3 。- 如果这是我选中的数字，你的总费用为 $7 。否则，你需要支付 $3 。- 如果我的数字更大，则下一步需要猜测的数字范围是 [4,6] 。你可以猜测数字为 5 。- 如果这是我选中的数字，你的总费用为 $7 + $3 = $10 。否则，你需要支付 $5 。- 如果我的数字更大，那么这个数字一定是 6 。你猜测数字为 6 并赢得游戏，总费用为 $7 + $3 + $5 = $15 。- 如果我的数字更小，那么这个数字一定是 4 。你猜测数字为 4 并赢得游戏，总费用为 $7 + $3 + $5 = $15 。- 如果我的数字更小，则下一步需要猜测的数字范围是 [1,2] 。你可以猜测数字为 1 。- 如果这是我选中的数字，你的总费用为 $7 + $3 = $10 。否则，你需要支付 $1 。- 如果我的数字更大，那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏，总费用为 $7 + $3 + $1 = $11 。
在最糟糕的情况下，你需要支付 $16 。因此，你只需要 $16 就可以确保自己赢得游戏。

示例 2：

输入：n = 1
输出：0
解释：只有一个可能的数字，所以你可以直接猜 1 并赢得游戏，无需支付任何费用。

示例 3：

输入：n = 2
输出：1
解释：有两个可能的数字 1 和 2 。
- 你可以先猜 1 。- 如果这是我选中的数字，你的总费用为 $0 。否则，你需要支付 $1 。- 如果我的数字更大，那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏，总费用为 $1 。
最糟糕的情况下，你需要支付 $1 。

提示：

  • 1 <= n <= 200
class Solution {
public:int getMoneyAmount(int n) {}
};

解析代码1_爆搜递归（超时）

  • 递归含义：给 dfs 一个区间 [left, right] ，返回在这个区间上能完胜的最小费用。
  • 函数体：选择 [left, right] 区间上的任意一个数作为头结点，然后递归分析左右子树。 求出所有情况下的最小值。因为要得到这个区间上能完胜的最小费用，所以选择左右子树时要求最大值。
  • 递归出口：当 left >= right 的时候，直接返回 0 。
class Solution {
public:int getMoneyAmount(int n) {return dfs(1, n);}int dfs(int left, int right){if(left >= right)return 0;int ret = INT_MAX;for(int i = left; i <= right; ++i){ret = min(ret, max(dfs(left, i - 1), dfs(i + 1, right)) + i);}return ret;}
};

解析代码2_记忆化搜索

记忆化搜索解法：

  • 加上一个备忘录。
  • 每次进入递归的时候，去备忘录里面看看。
  • 每次返回的时候，将结果加入到备忘录里面。
class Solution {int memo[201][201];
public:int getMoneyAmount(int n) {return dfs(1, n);}int dfs(int left, int right){if(left >= right)return 0;if(memo[left][right] != 0)return memo[left][right];int ret = INT_MAX;for(int i = left; i <= right; ++i){ret = min(ret, max(dfs(left, i - 1), dfs(i + 1, right)) + i);}memo[left][right] =ret;return ret;}
};

⑤力扣329. 矩阵中的最长递增路径

329. 矩阵中的最长递增路径

难度 困难

给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你 不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）。

示例 1：

输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
输出：4 
解释：最长递增路径为 [1, 2, 6, 9]。

示例 2：

输入：matrix = [[3,4,5],[3,2,6],[2,2,1]]
输出：4 
解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

示例 3：

输入：matrix = [[1]]
输出：1

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 200
  • 0 <= matrix[i][j] <= 2^31 - 1
class Solution {
public:int longestIncreasingPath(vector<vector<int>>& matrix) {}
};

解析代码1_爆搜递归（超时）

  • 递归含义：给 dfs 一个下标 [i, j] ，返回从这个位置开始的最长递增路径的长度。
  • 函数体：上下左右四个方向看一看，哪里能过去就过去，统计四个方向上的最大长度。
  • 递归出口：因为是先判断再进入递归，因此没有出口。
class Solution {int dx[4] = {0, 0, -1, 1};int dy[4] = {1, -1, 0, 0};int m = 0, n = 0;
public:int longestIncreasingPath(vector<vector<int>>& matrix) {m = matrix.size(), n = matrix[0].size();int ret = 0;for(int i = 0; i < m; ++i){for(int j = 0; j < n; ++j){ret = max(ret, dfs(i, j, matrix));}}return ret + 1; // 加上自己}int dfs(int sr, int sc, vector<vector<int>>& matrix){int ret = 0;for(int i = 0; i < 4; ++i){int x = sr + dx[i], y = sc + dy[i];if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[sr][sc]){ret = max(ret, dfs(x, y, matrix) + 1);}}return ret;}
};

解析代码2_记忆化搜索

记忆化搜索解法：

  • 加上一个备忘录。
  • 每次进入递归的时候，去备忘录里面看看。
  • 每次返回的时候，将结果加入到备忘录里面。
class Solution {int dx[4] = {0, 0, -1, 1};int dy[4] = {1, -1, 0, 0};int m = 0, n = 0;int memo[201][201];
public:int longestIncreasingPath(vector<vector<int>>& matrix) {m = matrix.size(), n = matrix[0].size();int ret = 0;for(int i = 0; i < m; ++i){for(int j = 0; j < n; ++j){ret = max(ret, dfs(i, j, matrix));}}return ret + 1; // 加上自己}int dfs(int sr, int sc, vector<vector<int>>& matrix){if(memo[sr][sc] != 0)return memo[sr][sc];int ret = 0;for(int i = 0; i < 4; ++i){int x = sr + dx[i], y = sc + dy[i];if(x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[sr][sc]){ret = max(ret, dfs(x, y, matrix) + 1);}}memo[sr][sc] = ret;return ret;}
};

本篇完。

下一篇是贪心算法的第四部分。

这篇关于Offer必备算法37_记忆化搜索_五道力扣题详解（由易到难）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/975142。

相关文章

Mysql 中的多表连接和连接类型详解

Mysql 中的多表连接和连接类型详解

《Mysql中的多表连接和连接类型详解》这篇文章详细介绍了MySQL中的多表连接及其各种类型,包括内连接、左连接、右连接、全外连接、自连接和交叉连接,通过这些连接方式,可以将分散在不同表中的相关数据... 目录什么是多表连接？1. 内连接（INNER JOIN）2. 左连接（LEFT JOIN 或 LEFT
阅读更多...
Java中switch-case结构的使用方法举例详解

Java中switch-case结构的使用方法举例详解

《Java中switch-case结构的使用方法举例详解》：本文主要介绍Java中switch-case结构使用的相关资料,switch-case结构是Java中处理多个分支条件的一种有效方式,它... 目录前言一、switch-case结构的基本语法二、使用示例三、注意事项四、总结前言对于Java初学者
阅读更多...
Linux内核之内核裁剪详解

Linux内核之内核裁剪详解

《Linux内核之内核裁剪详解》Linux内核裁剪是通过移除不必要的功能和模块,调整配置参数来优化内核,以满足特定需求,裁剪的方法包括使用配置选项、模块化设计和优化配置参数,图形裁剪工具如makeme... 目录简介一、 裁剪的原因二、裁剪的方法三、图形裁剪工具四、操作说明五、make menuconfig
阅读更多...
详解Java中的敏感信息处理

详解Java中的敏感信息处理

《详解Java中的敏感信息处理》平时开发中常常会遇到像用户的手机号、姓名、身份证等敏感信息需要处理,这篇文章主要为大家整理了一些常用的方法,希望对大家有所帮助... 目录前后端传输AES 对称加密RSA 非对称加密混合加密数据库加密MD5 + Salt/SHA + SaltAES 加密平时开发中遇到像用户的
阅读更多...
Springboot使用RabbitMQ实现关闭超时订单(示例详解)

Springboot使用RabbitMQ实现关闭超时订单(示例详解)

《Springboot使用RabbitMQ实现关闭超时订单(示例详解)》介绍了如何在SpringBoot项目中使用RabbitMQ实现订单的延时处理和超时关闭,通过配置RabbitMQ的交换机、队列和... 目录1.maven中引入rabbitmq的依赖：2.application.yml中进行rabbit
阅读更多...
C语言线程池的常见实现方式详解

C语言线程池的常见实现方式详解

《C语言线程池的常见实现方式详解》本文介绍了如何使用C语言实现一个基本的线程池,线程池的实现包括工作线程、任务队列、任务调度、线程池的初始化、任务添加、销毁等步骤,感兴趣的朋友跟随小编一起看看吧... 目录1. 线程池的基本结构2. 线程池的实现步骤3. 线程池的核心数据结构4. 线程池的详细实现4.1 初
阅读更多...
Python绘制土地利用和土地覆盖类型图示例详解

Python绘制土地利用和土地覆盖类型图示例详解

《Python绘制土地利用和土地覆盖类型图示例详解》本文介绍了如何使用Python绘制土地利用和土地覆盖类型图,并提供了详细的代码示例,通过安装所需的库,准备地理数据,使用geopandas和matp... 目录一、所需库的安装二、数据准备三、绘制土地利用和土地覆盖类型图四、代码解释五、其他可视化形式1.
阅读更多...
SpringBoot使用Apache POI库读取Excel文件的操作详解

SpringBoot使用Apache POI库读取Excel文件的操作详解

《SpringBoot使用ApachePOI库读取Excel文件的操作详解》在日常开发中,我们经常需要处理Excel文件中的数据,无论是从数据库导入数据、处理数据报表,还是批量生成数据,都可能会遇到... 目录项目背景依赖导入读取Excel模板的实现代码实现代码解析ExcelDemoInfoDTO 数据传输
阅读更多...
如何用Java结合经纬度位置计算目标点的日出日落时间详解

如何用Java结合经纬度位置计算目标点的日出日落时间详解

《如何用Java结合经纬度位置计算目标点的日出日落时间详解》这篇文章主详细讲解了如何基于目标点的经纬度计算日出日落时间,提供了在线API和Java库两种计算方法,并通过实际案例展示了其应用,需要的朋友... 目录前言一、应用示例1、天安门升旗时间2、湖南省日出日落信息二、Java日出日落计算1、在线API2
阅读更多...
使用Spring Cache时设置缓存键的注意事项详解

使用Spring Cache时设置缓存键的注意事项详解

《使用SpringCache时设置缓存键的注意事项详解》在现代的Web应用中,缓存是提高系统性能和响应速度的重要手段之一,Spring框架提供了强大的缓存支持,通过​​@Cacheable​​、​​... 目录引言1. 缓存键的基本概念2. 默认缓存键生成器3. 自定义缓存键3.1 使用​​@Cacheab
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2