动态规划入门：斐波那契数列模型以及多状态（C++）

斐波那契数列模型以及多状态

    • 动态规划简述
    • 斐波那契数列模型
      • 1.第 N 个泰波那契数（简单）
      • 2.三步问题（简单）
      • 3.使⽤最⼩花费爬楼梯（简单）
      • 4.解码方法（中等）
    • 简单多状态
      • 1.打家劫舍（中等）
      • 2.打家劫舍II（中等）
      • 3.粉刷房子（中等）
      • 4.删除并获得点数（中等）
      • 5.买卖股票的最佳时期含⼿续费（中等）
      • 6.买卖股票的最佳时机含冷冻期（中等）
      • 7.买卖股票的最佳时机III（困难）
      • 8.买卖股票的最佳时机IV（困难）

动态规划简述

    动态规划(Dynamic programming，简称 DP)是一种解决多阶段决策问题的算法思想。它将问题分解为多个阶段，并通过保存中间结果来避免重复计算，从而提高效率。


动态规划的解题步骤一般分为以下几步：

  1. 思考状态表示，创建dp表(重点)
  2. 分析出状态转移方程(重点)
  3. 初始化
  4. 确定填表顺序
  5. 确定返回值

斐波那契数列模型

1.第 N 个泰波那契数（简单）

链接：第 N 个泰波那契数

  • 题目描述

在这里插入图片描述

  • 做题步骤
  1. 状态表示

面对动态规划问题，我们一般有两种状态表示：

  1. 以某一个位置为起点，……
  2. 以某一个位置为终点，……

我们一般优先考虑第1种表示，但如果第1种无法解决就考虑第2种。

在这里插入图片描述

  1. 状态转移方程
    这个题目直接告诉了我们状态转移方程：dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]

  2. 初始化
    泰波那契数的第0、1、2个是特殊的，不满足状态转移方程，因此我们需要初始化这三个位置为0、1、1

  3. 填表顺序
    保证填当前状态时，所需状态已经计算过，填表顺序很明显是从左往右

  4. 返回值
    根据状态表示，假设要求的是第n个，返回的应该是dp[n]

  • 代码实现
class Solution {
public:int tribonacci(int n) {//对于第0、1、2单独处理if(n == 0) return 0;if(n == 1 || n == 2)return 1;//dp[i]：第i个泰波那契数vector<int> dp(n + 1);dp[0] = 0; dp[1] = 1; dp[2] = 1; for(int i = 3; i < n + 1; i++){dp[i] = dp[i-1] + dp[i-2] + dp[i-3];}return dp[n];//空间复杂度：O(N)//时间复杂度：O(N)}
};//不知道大家有没有发现向后填表的过程其实只需要前置的3个状态
//其余的状态都是多余的，我们可以用有限的变量来保存这些状态，这样就实现了空间优化
//这种优化方式被称为“滚动数组”
//经过优化原O(N)->O(1) O(N^2)->O(N)
//但这并不是动态规划讲解的要点，所以我只会把两种优化情况的代码给出// class Solution {
// public:
//     int tribonacci(int n) 
//     {
//         if(n == 0) 
//             return 0;
//         if(n == 1 || n == 2)
//             return 1;//         int t1 = 0;
//         int t2 = 1;
//         int t3 = 1;
//         int ret = 0;//         for(int i = 3; i < n + 1; i++)
//         {
//             ret = t1 + t2 + t3;
//             t1 = t2;
//             t2 = t3;
//             t3 = ret;
//         }
//         return ret;
//     }
// };

2.三步问题（简单）

链接：三步问题

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    在这里插入图片描述

  2. 状态转移方程
    到达i阶可以转换成先到达i - 3、i - 2、i - 1阶，三者相加得到结果，所以状态转移方程为：dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]。

  3. 初始化
    为了保证填表不越界，我们把到达1、2、3阶的方法初始化。

  4. 填表顺序
    保证填当前状态时，所需状态已经计算过，填表顺序从左往右。

  5. 返回值
    根据状态表示，假设要求的是n阶，返回的应该是dp[n]

  • 代码实现
class Solution {
public:int waysToStep(int n) {//1、2、3阶特殊处理if(n == 1) return 1;if(n == 2) return 2;if(n == 3) return 4;//dp[i]表示到达i阶的方法数vector<int> dp(n+1); //多开一个空间，可以让下标和层数对应dp[1] = 1; dp[2] = 2; dp[3] = 4;const int mod = 1e9 + 7;  //有可能超出，需要取模for(int i = 4; i < n + 1; i++){dp[i] = ((dp[i-1] + dp[i-2]) % mod + dp[i-3]) % mod;}return dp[n];//时间复杂度：O(N)//空间复杂度：O(N)}
};

3.使⽤最⼩花费爬楼梯（简单）

链接：使⽤最⼩花费爬楼梯

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    这个题目的思路和第2题很相似，要到达终点n阶，我们可以从n - 1阶走一步、n - 2阶走两步到终点，从中选择费用最低的一方(从当前阶离开需要支付离开费用)；至于到达n - 1、n - 2阶的最低费用，我们可以以n - 1、n - 2层为终点进行分析，依此类推。到达终点的过程需要到达每一层的最低费用，我们可以用一个dp表存储，dp[i]表示到达下标i台阶所需要的最低费用。

  2. 状态转移方程
    到达i阶的最低花费可以转换为min(到达i - 1阶的最低花费 + 走出这一阶的花费， 到达i - 2阶的最低花费 + 走出这一阶的花费)，所以状态转移方程为：dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])。

  3. 初始化
    由转移方程可知更新某个状态需要前置的两个状态，为了确保填表时不越界，单独处理走到0、1阶的最低花费。

  4. 填表顺序
    保证填当前状态时，所需状态已经计算过，填表顺序从左往右。

  5. 返回值
    根据状态表示，假设数组有n个元素(终点是n阶)，返回的应该是dp[n]

  • 代码实现
class Solution {
public:int minCostClimbingStairs(vector<int>& cost) {      //dp[i] 表示到这一层的最小花费int n = cost.size();vector<int> dp(n + 1);//一开始就可以在0或1阶，花费为0，vector默认给0，不用处理for(int i = 2; i < n + 1; i++){dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);}return dp[n];//空间复杂度：O(N)//时间复杂度：O(N)}
};// //第二种写法：反着来，以某个位置为起点，……
// class Solution {
// public:
//     int minCostClimbingStairs(vector<int>& cost) 
//     {      
//         //dp[i]：这一层为起点，到终点的最低花费
//         int n = cost.size();
//         vector<int> dp(n + 1);
//         dp[n] = 0;
//         dp[n - 1] = cost[n - 1];
//         for(int i = n - 2; i >= 0; i--)
//         {            
//             dp[i] = min(dp[i + 1] + cost[i], dp[i + 2] + cost[i]);
//         }//         return min(dp[0], dp[1]);
//     }
// };

4.解码方法（中等）

链接：解码方法

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    在这里插入图片描述

  2. 状态表示
    除去第一位，每个位置都有单独解码和联合解码两种方式，n位置的状态转移方程为：dp[n] = dp[n - 1]（单独解码成功）+ dp[n - 2]（联合解码成功）

  3. 初始化
    依据状态转移方程，某位置状态需要前置的两个状态，为了避免越界，我们需要单独处理第1、2个位置，但观察上面的分析过程，可以发现第2个位置和其它位置一样也有两种解码可能，我们可以在dp表前面多加个虚拟节点并初始为1，这样就只需要处理第1个位置了。（看图看图）

在这里插入图片描述

  1. 填表顺序
    保证填当前状态时，所需状态已经计算过，填表顺序从左往右。

  2. 返回值
    依据状态定义，假设序列长度为n，返回的应该是以n位置为结尾的解码可能数，即dp[n]。

  • 代码实现
class Solution {
public:int numDecodings(string s) {int n = s.size();//dp[i]表示以i位置为结尾的解码可能数vector<int> dp(n + 1);//第一个位置就为0，最终结果已经是0if(s[0] == '0')return 0;//初始化虚拟节点和第1个位置dp[1] = dp[0] = 1;for(int i = 2; i < n + 1; i++){//单独解码if(s[i - 1] != '0')                      dp[i] += dp[i-1];//联合解码（联合解码小于10说明存在前导0，无法联合解码）int com = (s[i - 2] - '0') * 10 + (s[i - 1] - '0');if(com >= 10 && com <= 26)                       dp[i] += dp[i-2];//都失败的情况是'00'，最终结果已经是0，这里可不加//两个连续的0，后面全都是0if(dp[i] == 0)return 0;        }return dp[n];}
};

简单多状态

1.打家劫舍（中等）

链接：打家劫舍

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    依据前面的做题经验，我们可以把状态表示为以i位置为结尾的最大偷窃金额，但每个位置有偷和不偷两种选择，所以可以把状态再进行细化：状态f表示以i位置为结尾并偷窃本位置的最大金额；状态g表示以i位置为结尾但不偷窃本位置的最大金额。

在这里插入图片描述

  1. 状态转移方程
    由前面的分析可知，要偷i位置(f)需要i - 1位置不偷(g)的最大金额，不偷i位置就选择i - 1位置偷和不偷两种选择中大的一方，所以状态转移方程为：
    (1) f[i] = g[i - 1] + nums[ i ] (本位置可偷金额)；
    (2) g[i] = max(g[i - 1], f[i - 1])

  2. 初始化
    由状态转移方程可知当今状态需要前一个状态，为保证填表时不越界，单独处理第一个位置：f[0] = nums[0]，g[0] = 0。

  3. 填表顺序
    保证填当前状态时，所需状态已经计算过，填表顺序从左往右。

  4. 返回值
    把自己代入成小偷，相邻位置不能同时偷的情况下是需要进行选择的，但偷的过程中不知道后面房子的价值，只能走一步看一步，保证每一步都是最好的，偷到最后一定是最优结果。假设数组有n个元素，返回值为max(f[n - 1], g[n - 1])。

  • 代码实现
class Solution {
public:int rob(vector<int>& nums) {int n = nums.size();vector<int> f(n); //f[i]表示到底这个位置并偷窃的最大金额auto g = f;  //g[i]表示到达这个位置不偷窃的最大金额f[0] = nums[0]; //初始化f[0],g[0]默认0不用处理for(int i = 1; i < n; i++){f[i] = g[i - 1] + nums[i];g[i] = max(g[i - 1], f[i - 1]);}return max(f[n - 1], g[n - 1]);//空间复杂度：O(N)//时间复杂度：O(N)}
};

2.打家劫舍II（中等）

链接：打家劫舍II

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    这个题和前一个题唯一的不同只有首尾成环这一个点，我们延用上个题目的状态表示：状态f表示以i位置为结尾并偷窃本位置的最大金额；状态g表示以i位置为结尾但不偷窃本位置的最大金额。
    处理成环问题，最直接的思路就是拆解。
    在这里插入图片描述

  2. 状态转移方程
    和上一道题目一致，状态转移方程为：
    (1) f[i] = g[i - 1] + nums[ i ] (本位置可偷金额)；
    (2) g[i] = max(g[i - 1], f[i - 1])

  3. 初始化
    和上一道题目一致。

  4. 填表顺序
    从左往右。

  5. 返回值
    _rob函数表示指定区间的打家劫舍，返回值为：
    max(nums[0] + _rob(nums, 2, n - 2), _rob(nums, 1, n - 1))。

  • 代码实现
class Solution {
public:int _rob(vector<int>& nums, int left,int right) {//区间不存在返回0if(left > right)return 0;int n = nums.size();vector<int> f(n);  //到这个屋子偷的最大金额auto g = f; //到这个屋子不偷的最大金额f[left] = nums[left];for(int i = left + 1; i <= right; i++){f[i] = g[i - 1] + nums[i];g[i] = max(f[i - 1],g[i - 1]);}return max(f[right],g[right]);}int rob(vector<int>& nums) {int n = nums.size();return max(nums[0] + _rob(nums, 2, n - 2), _rob(nums, 1, n - 1));}
};

3.粉刷房子（中等）

链接：粉刷房子

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    依据经验和题目要求，我们可以把状态定义为把第i号房子粉刷成j颜色的最小花费。
    在这里插入图片描述

  2. 状态转移方程
    状态转移方程为(0是红色、1是蓝色、2是绿色)：
    (1)dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + cost[i][0]（花费）
    (2)dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + cost[i][1]
    (3)dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i][2]

  3. 初始化
    为了保证填表不越界，我们要初始化第一行的值，但是那样太麻烦了，我们可以多开一行并初始化0，这样就不用单独处理第一行了。（注意和cost数组的下标对应关系）

  4. 填表顺序
    从上往下，每一行从左往右。

5.返回值
依据状态表示，假设最后的房子是i号，返回值为min({dp[n][0], dp[n][1], dp[n][2]})。

  • 代码实现
class Solution {
public:int minCost(vector<vector<int>>& costs){int n = costs.size();//dp[i][j]表示第i号房子粉刷成j颜色的最低花费//其中0表示红色，1表示蓝色，2表示绿色vector<vector<int>> dp(n + 1, vector<int>(3));//空间多开一行并初始化0，不用单独处理第一行for (int i = 1; i < n + 1; i++){dp[i][0] = costs[i - 1][0] + min(dp[i - 1][1], dp[i - 1][2]);dp[i][1] = costs[i - 1][1] + min(dp[i - 1][0], dp[i - 1][2]);dp[i][2] = costs[i - 1][2] + min(dp[i - 1][0], dp[i - 1][1]);}return min({dp[n][0], dp[n][1], dp[n][2]});//时间复杂度：O(N)//空间复杂度：O(N)}
};

4.删除并获得点数（中等）

链接：删除并获得点数

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    在这里插入图片描述

  2. 状态转移方程
    这个题就是变形的“打家劫舍”，转移方程一致：
    (1) f[i] = g[i - 1] + v[ i ] (删除本位置可得点数)；
    (2) g[i] = max(g[i - 1], f[i - 1])

  3. 初始化
    数组转化完成后dp表不需要处理。

  4. 填表顺序
    从左往右。

  5. 返回值
    返回值为max(f[N - 1],g[N - 1])

  • 代码实现
class Solution {
public:int deleteAndEarn(vector<int>& nums){int n = nums.size();//创建数组进行映射//题目中1 <= nums[i] <= 10000const int N = 10001;int v[N] = {0};for(auto val : nums)v[val] += val;//“打家劫舍”vector<int> f(N); //f[i]表示以i区域为结尾并且删除本区域的最大点数auto g = f;  //g[i]表示以i区域为结尾但不删除本区域的最大点数for (int i = 1; i < N; i++){f[i] = g[i - 1] + v[i];g[i] = max(f[i - 1], g[i - 1]);}return max(f[N - 1],g[N - 1]);//时间复杂度：O(N)//空间复杂度：O(1)}
};//上面的写法简洁一些，但无论数据量多少都会遍历10000次
//可以记录数组的最大、最小值，来加快速度
// class Solution {
// public:
//     int deleteAndEarn(vector<int>& nums)
//     {
//         int n = nums.size();
//         vector<int> v(10001);
//         //先遍历一次
//         int _max = nums[0];
//         int _min = nums[0];
//         for (int i = 0; i < n; i++)
//         {
//             v[nums[i]] += nums[i];
//             _max = max(_max, nums[i]);
//             _min = min(_min, nums[i]);
//         }//         vector<int> f(10001);
//         auto g = f;
//         for (int i = _min; i <= _max; i++)
//         {
//             f[i] = g[i - 1] + v[i];
//             g[i] = max(f[i - 1], g[i - 1]);
//         }//         return max(f[_max],g[_max]);
//     }
// };

5.买卖股票的最佳时期含⼿续费（中等）

链接：买卖股票的最佳时期含⼿续费

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    在这里插入图片描述

dp[i][j]：第i天结束时处于j状态的最大利润。

  1. 状态转移方程，0表示结束有股票，1表示结束没有股票，fee是手续费，prices[i]表示第i天的股票价格
    (1)dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i])
    (2)dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee)

  2. 初始化
    初始化第0天状态即可，dp[0][0] -= prices[0];。

  3. 填表顺序
    从上到下。

  4. 返回值
    返回值为：max(dp[n - 1][1], dp[n - 1][0])。

  • 代码实现
class Solution {
public:int maxProfit(vector<int>& prices, int fee) {int n = prices.size();//dp[i][j]:第i天结束处于j状态的最大利润vector<vector<int>> dp(n, vector<int>(2));//这种解法买入还是卖出交手续费都一样(反正买入了一定会卖出)dp[0][0] -= prices[0];for(int i = 1; i < n; i++){dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);}return max(dp[n - 1][1], dp[n - 1][0]);//时间复杂度：O(N)//空间复杂度：O(N)}
};

6.买卖股票的最佳时机含冷冻期（中等）

链接：买卖股票的最佳时机含冷冻期

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    在这里插入图片描述

  2. 状态转移方程
    0是买入（有股票）、1是可交易、2是冷冻，prices[i]表示第i天的股票价格，状态转移方程为：
    (1)dp[i][0] = max(dp[i - 1][1] - prices[i], dp[i - 1][0])
    (2)dp[i][1] = max(dp[i - 1][2], dp[i - 1][1])
    (3)dp[i][2] = dp[i - 1][0] + prices[i]

  3. 初始化
    当前天的三种状态需要前一天的状态，所以初始化dp表的第一行
    dp[0][0]：想该天结束后处于买入状态，必须把股票买了，dp[0][0] = -prices[i]；
    dp[0][1]：什么都不干，dp[0][1] = 0；
    dp[0][2]：想该天结束处于冷冻，在同一天买入和卖出，dp[0][2] = 0；

  4. 填表顺序
    从上到下。

  5. 返回值
    最大值应该手中没有股票，假设数组有n个元素，最大值为max(dp[n - 1][1], dp[n - 1][ 2 ])。

  • 代码实现
class Solution {
public:int maxProfit(vector<int>& prices) {int n = prices.size();//dp[i][j]：第i天结束后处于j状态时的最大利润vector<vector<int>> dp(n, vector<int>(3));//初始化dp[0][0] -= prices[0];for(int i = 1; i < n; i++){dp[i][0] = max(dp[i - 1][1] - prices[i], dp[i - 1][0]);dp[i][1] = max(dp[i - 1][2], dp[i - 1][1]);dp[i][2] = dp[i - 1][0] + prices[i];}return max(dp[n - 1][2],dp[n - 1][1]);}
};

7.买卖股票的最佳时机III（困难）

链接：买卖股票的最佳时机III

  • 题目描述
    在这里插入图片描述

  • 做题步骤

  1. 状态表示
    在这里插入图片描述

  2. 状态转移方程
    由前面的分析可知，状态转移方程为：
    (1)f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i])
    (2)if(j >= 1) g[i][j] = max(g[i - 1][j], f[i - 1][j - 1] + prices[i])
      else g[i][j] = g[i - 1][j]

  3. 初始化
    需要i = 0的状态，初始化第一行。
    (1)处于第一行的时候只有f[0][0]和g[0][0]存在，f[0][0] = -prices[0]，g[0][0] = 0。
    (2)为了避免不存在的状态干扰取max值，我们把不存在的状态统一初始化为 INT_MIN / 2。（INT_MIN会越界，尽可能小就行）

  4. 填表顺序
    从上往下填每一列，从左往右填每一行。

  5. 返回值
    返回最后一行的最大值即可。

  • 代码实现
class Solution {
public://可能会越界,取INT_MIN的一半const int INF = INT_MIN / 2;int maxProfit(vector<int>& prices) {int n = prices.size();//dp[i][j]表示在第i天结束后完成j次交易，处于""状态下的最大利润vector<vector<int>> f(n, vector<int>(3, INF));  //买入auto g = f;  //可交易//初始化f[0][0] = -prices[0];g[0][0] = 0;for (int i = 1; i < n; i++){for(int j = 0; j < 3; j++){f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);g[i][j] = g[i - 1][j];//j == 0的时候前置状态f[i - 1][j - 1]不存在if(j >= 1)g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);}                                    }return max({g[n - 1][0], g[n - 1][1], g[n - 1][2]});}
};

8.买卖股票的最佳时机IV（困难）

这个题目的思考方式和第7题完全一致，大家可以先自己试着做一下。
链接：买卖股票的最佳时机IV

  • 代码实现
class Solution {
public:const int INF = INT_MIN / 2;int maxProfit(int k, vector<int>& prices) {           int n = prices.size();//n天最多完成n / 2次交易，k不能超过这个值k = min(k, n / 2);//买入//dp[i][j]表示在第i天结束后完成j次交易，处于""状态下的最大利润vector<vector<int>> f(n, vector<int>(k + 1, INF));//卖出auto g = f;//初始化(先买再说)f[0][0] = -prices[0];g[0][0] = 0;for (int i = 1; i < n; i++){for(int j = 0; j <= k; j++){f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);g[i][j] = g[i - 1][j];if(j >= 1)g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);}                                    }int ret = g[n - 1][0];//把利润最大的那个找出来for(int j = 1; j <= k; j++){ret = max(ret, g[n - 1][j]);}return ret;}
};

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

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

相关文章

Redis 重写 AOF 日志期间，主进程可以正常处理命令吗？

Redis 重写 AOF 日志期间，主进程可以正常处理命令吗？

重写 AOF 日志的过程是怎样的&#xff1f; Redis 的重写 AOF 过程是由后台子进程 bgrewriteaof 来完成的&#xff0c;这么做有以下两个好处。 子进程进行 AOF 重写期间&#xff0c;主进程可以继续处理命令请求&#xff0c;从而避免阻塞主进程子进程带有主进程的数据副本。这里…
阅读更多...
leetcode359周赛

leetcode359周赛

2828. 判别首字母缩略词 核心思想:枚举。只需要枚举首字母和s是否一一对应即可。 2829. k-avoiding 数组的最小总和 核心思想&#xff1a;自己的方法就是哈希表&#xff0c;枚举i的时候&#xff0c;将k-i统计起来&#xff0c;如果出现了那么就跳过。灵神的方法是数学法&#…
阅读更多...
OpenCV项目开发实战--基于Python/C++实现鼠标注释图像和轨迹栏来控制图像大小

OpenCV项目开发实战--基于Python/C++实现鼠标注释图像和轨迹栏来控制图像大小

鼠标指针是图形用户界面 (GUI) 中的关键组件。没有它，您就无法真正考虑与 GUI 进行交互。那么，让我们深入了解 OpenCV 中鼠标和轨迹栏的内置函数。我们将演示如何使用鼠标来注释图像，以及如何使用轨迹栏来控制图像的大小 我们将使用下图来演示 OpenCV 中鼠标指针和轨迹栏功能…
阅读更多...
stm32之16.外设定时器——TIM3

stm32之16.外设定时器——TIM3

----------- 源码 void tim3_init(void) {NVIC_InitTypeDef NVIC_InitStructure;TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;//使能TIM3的硬件时钟RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);//配置TIM3的定时时间TIM_TimeBaseStructure.TIM_Period 10000-1…
阅读更多...
短视频seo源码矩阵系统开源---代码php分享

短视频seo源码矩阵系统开源---代码php分享

前言&#xff1a;短视频seo源码 短视频seo矩阵系统源码私有化部署 短视频seo源码 短视频seo矩阵系统源码私有化怎么部署&#xff1f; 首先我们来给大家普及一下什么是短视频seo矩阵系统&#xff1f;视频矩阵分为多平台矩阵与一个平台多账号矩阵&#xff0c;加上seo排名优化&…
阅读更多...
R语言快速生成三线表(1)

R语言快速生成三线表(1)

R语言的优势在于批量处理&#xff0c;常使用到循环和函数&#xff0c;三线表是科研文章中必备的内容。利用函数实现自动判断数据类型和计算。使用R包&#xff08;table1&#xff09;。 # 创建连续性变量 continuous_var1 <- c(1.2, 2.5, 3.7, 4.8, 5.9) continuous_var2 &l…
阅读更多...
uniapp踩坑合集

uniapp踩坑合集

1、onPullDownRefresh下拉刷新不生效 pages.json对应的style中enablePullDownRefresh设置为true&#xff0c;开启下拉刷新 {"path" : "pages/list/list","style" :{"navigationBarTitleText": "页面标题名称","enable…
阅读更多...
Mybatis的动态SQL分页及特殊字符的使用

Mybatis的动态SQL分页及特殊字符的使用

目录 一、分页 ( 1 ) 应用场景 ( 2 ) 使用 二、特殊字符 2.1 介绍 2.2 使用 给我们带来的收获 一、分页 分页技术的出现是为了解决大数据量展示、页面加载速度、页面长度控制和用户体验等问题。通过将数据分成多个页面&#xff0c;用户可以根据需求选择查看不同页的数据…
阅读更多...
Oracle 查询（当天，月，年）的数据

Oracle 查询（当天，月，年）的数据

Trunc 在oracle中&#xff0c;可利用 trunc函数 查询当天数据&#xff0c;该函数可用于截取时间或者数值&#xff0c;将该函数与 select 语句配合使用可查询时间段数据 查询当天数据 --sysdate是获取系统当前时间函数 --TRUNC函数用于截取时间或者数值&#xff0c;返回指定的…
阅读更多...
Leetcode.73矩阵置零

Leetcode.73矩阵置零

给定一个 m x n 的矩阵&#xff0c;如果一个元素为 0 &#xff0c;则将其所在行和列的所有元素都设为 0 。请使用 原地 算法 class Solution {public void setZeroes(int[][] matrix) {int m matrix.length, n matrix[0].length;boolean[] row new boolean[m];boolean[] col…
阅读更多...
机器学习基础之《分类算法（5）—朴素贝叶斯算法原理》

机器学习基础之《分类算法（5）—朴素贝叶斯算法原理》

一、朴素贝叶斯算法 1、什么是朴素贝叶斯分类方法 之前用KNN算法&#xff0c;分类完直接有个结果&#xff0c;但是朴素贝叶斯分完之后会出现一些概率值&#xff0c;比如&#xff1a; 这六个类别&#xff0c;它都有一定的可能性 再比如&#xff0c;对文章进行分类&#xff1a;…
阅读更多...
算法leetcode｜73. 矩阵置零（rust重拳出击）

算法leetcode｜73. 矩阵置零（rust重拳出击）

文章目录 73. 矩阵置零&#xff1a;样例 1&#xff1a;样例 2&#xff1a;提示&#xff1a;进阶&#xff1a; 分析&#xff1a;题解&#xff1a;rust&#xff1a;go&#xff1a;c&#xff1a;python&#xff1a;java&#xff1a; 73. 矩阵置零&#xff1a; 给定一个 m x n 的矩…
阅读更多...
【PHP】函数-作用域可变函数匿名函数闭包常用系统函数

【PHP】函数-作用域可变函数匿名函数闭包常用系统函数

文章目录 函数定义&使用命名规则参数种类默认值引用传递函数返回值return关键字 作用域global关键字静态变量 可变函数匿名函数闭包常用系统函数输出函数时间函数数学函数与函数相关函数 函数 函数&#xff1a;function&#xff0c;是一种语法结构&#xff0c;将实现某一个…
阅读更多...
Activity 的启动流程（Android 13）

Activity 的启动流程（Android 13）

Activity 的启动过程分为两种&#xff1a;一种是普通 Activity 的启动过程&#xff0c;另一种是根 Activity 的启动过程。普通 Activity 指的是除应用程序启动的第一个 Activity 之外的其他 Activity。根 Activity 指的是应用程序启动的第一个 Activity&#xff0c;因此&#x…
阅读更多...
Azure不可变Blob存储

Azure不可变Blob存储

文章目录 Azure不可变Blob存储介绍Azure不可变性策略实战演练 Azure不可变Blob存储介绍 不可变的存储是一种用于存储业务关键型 Blob 数据的存储方式。与可变存储相反&#xff0c;不可变存储的特点是一旦数据被写入后&#xff0c;便无法再对其进行修改或删除。这种存储方式提供…
阅读更多...
【leetcode 力扣刷题】交换链表中的节点

【leetcode 力扣刷题】交换链表中的节点

24. 两两交换链表中的节点 24. 两两交换链表中的节点两两节点分组&#xff0c;反转两个节点连接递归求解 24. 两两交换链表中的节点 题目链接&#xff1a;24. 两两交换链表中的节点 题目内容&#xff1a; 题目中强调不能修改节点内部值&#xff0c;是因为如果不加这个限制的话…
阅读更多...
实验室信息化管理系统的优势及发展趋势

实验室信息化管理系统的优势及发展趋势

随着现代化实验室的快速发展&#xff0c;实验室数据的管理和处理已经不再是单纯的人工填写、计算和报表编制&#xff0c;实验室管理工作的复杂性和艰巨性与日俱增&#xff0c;传统实验室的管理模式已经无法满足实验室管理的需求。为了解决这些问题&#xff0c;LIMS&#xff08;…
阅读更多...
Windows下编译NextCloud desktop 3.9.1

Windows下编译NextCloud desktop 3.9.1

首先从官方下载源码&#xff1a; https://github.com/nextcloud/desktop&#x1f4bb; Desktop sync client for Nextcloud. Contribute to nextcloud/desktop development by creating an account on GitHub.https://github.com/nextcloud/desktop 我选择的是3.9.1的稳定版本…
阅读更多...
Elasticsearch(十二)搜索---搜索匹配功能③--布尔查询及filter查询原理

Elasticsearch(十二)搜索---搜索匹配功能③--布尔查询及filter查询原理

一、前言 本节主要学习ES匹配查询中的布尔查询以及布尔查询中比较特殊的filter查询及其原理。 复合搜索&#xff0c;顾名思义是一种在一个搜索语句中包含一种或多种搜索子句的搜索。 布尔查询是常用的复合查询&#xff0c;它把多个子查询组合成一个布尔表达式&#xff0c;这些…
阅读更多...
Spring 为什么使用三级缓存解决循环依赖

Spring 为什么使用三级缓存解决循环依赖

文章目录 前言1. 什么是循环依赖1.1 互相依赖1.2 递归依赖 2. Sping中循环依赖有什么问题&#xff1f;3. 什么是三级缓存4. Spring 可以解决哪些情况的循环依赖&#xff1f; 二级缓存作用——普通循环依赖实操环节1. 实例化类A对象2. 实例化类B对象3. B对象完成创建4.继续创建A…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023