动态规划入门:斐波那契数列模型以及多状态(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.rhkb.cn/news/104907.html

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

相关文章

Docker常见配置实验

1、使用mysql:5.6和 owncloud 镜像&#xff0c;构建一个个人网盘。 1、拉取mysql5.6与owncloud的镜像 docker pull mysql:5.6 docker pull mysql:5.6 2、生成容器实例&#xff0c;构建个人网盘 docker run -d --name mydb1 --env MYSQL_ROOT_PASSWORD123456 mysql:5.6 docker …

【学习FreeRTOS】第17章——FreeRTOS任务通知

1.任务通知的简介 任务通知&#xff1a;用来通知任务的&#xff0c;任务控制块中的结构体成员变量 ulNotifiedValue就是这个通知值。 使用队列、信号量、事件标志组时都需另外创建一个结构体&#xff0c;通过中间的结构体进行间接通信&#xff01; 使用任务通知时&#xff0c…

element-table的动态操作,自动以表格,动态新增行、列,删除行列

灵活的自定义表格行列以及增删改查的操作,右键选中列则是列的删除&#xff0c;效果如下 <template><div class"st-table"><div style"width: 100%"><el-button click"addRow()" type"primary" icon"CircleP…

在CSS中,盒模型中的padding、border、margin是什么意思?

在CSS中&#xff0c;盒模型&#xff08;Box Model&#xff09;是用来描述和布局HTML元素的基本概念。它将每个HTML元素看作是一个矩形的盒子&#xff0c;这个盒子包括了内容&#xff08;content&#xff09;、内边距&#xff08;padding&#xff09;、边框&#xff08;border&a…

无涯教程-PHP - intval() 函数

PHP 7引入了一个新函数 intdiv()&#xff0c;该函数对其操作数执行整数除法并将该除法返回为int。 <?php$valueintdiv(10,3);var_dump($value);print(" ");print($value); ?> 它产生以下浏览器输出- int(3) 3 PHP - intval() 函数 - 无涯教程网无涯教程网…

【图像分割】实现snake模型的活动轮廓模型以进行图像分割研究(Matlab代码实现)

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…

raft算法学习备忘

一致性共识算法 参考:分布式一致性算法应用场景&#xff0c;写了为什么需要共识算法&#xff0c;以及相比于mysql这些主从同步方式的区别。 raft算法简介 一种分布式一致性共识算法的实现方式&#xff0c;机制相比于其它例如paxos来说无论从可读性还是实现机制上要简单很多&…

3种获取OpenStreetMap数据的方法【OSM】

OpenStreetMap 是每个人都可以编辑的世界地图。 这意味着你可以纠正错误、添加新地点&#xff0c;甚至自己为地图做出贡献&#xff01; 这是一个社区驱动的项目&#xff0c;拥有数百万注册用户。 这是一个社区驱动的项目&#xff0c;旨在在开放许可下向每个人提供所有地理数据。…

大数据课程K6——Spark的Shuffle详解

文章作者邮箱:yugongshiye@sina.cn 地址:广东惠州 ▲ 本章节目的 ⚪ 了解Spark的定义&&特点&&目的&&优缺点; ⚪ 掌握Spark的相关参数配置; ⚪ 掌握Hadoop的插件配置; 一、Spark Shuffle详解 1. 概述 Shuffle,就是洗牌。之所以…

安防监控平台EasyCVR视频汇聚平台增加首页告警类型的详细介绍

安防监控/视频集中存储/云存储EasyCVR视频汇聚平台&#xff0c;可支持海量视频的轻量化接入与汇聚管理。平台能提供视频存储磁盘阵列、视频监控直播、视频轮播、视频录像、云存储、回放与检索、智能告警、服务器集群、语音对讲、云台控制、电子地图、平台级联、H.265自动转码等…

vue3-ts- element-plus新增组件-过滤

新增组件-所有值为空时过滤 <el-form-item label"家庭成员"><divclass"username-box"v-for"(item, index) in form.namelist":key"index"><div>姓名&#xff1a;<el-input v-model"item.name" placeho…

Java异常

异常体系结构Java异常的分类异常处理异常抛出异常声明异常捕获异常处理流程自定义异常 异常体系结构 .Error&#xff1a;指的是Java虚拟机无法解决的严重问题&#xff0c;比如&#xff1a;JVM的内部错误、资源耗尽等&#xff0c;典型代表&#xff1a;StackOverflowError&#…

uniapp-滑块验证组件wo-slider

wo-slider是一款支持高度自定义的滑块验证组件&#xff0c;采用uniapp-vue2编写 采用touchstart、touchmove、touchend事件实现的滑块组件,支持H5、微信小程序&#xff08;其他小程序未试过&#xff0c;可自行尝试&#xff09; 可到插件市场下载尝试&#xff1a; https://ext.…

Docker搭建个人网盘、私有仓库

1、使用mysql:5.6和 owncloud 镜像&#xff0c;构建一个个人网盘 [rootlocalhost ~]# docker pull mysql:5.6 [rootlocalhost ~]# docker pull owncloud [rootlocalhost ~]# docker run -itd --name mysql --env MYSQL_ROOT_PASSWORD123456 mysql:5.6 [rootlocalhost ~]# doc…

1267. 统计参与通信的服务器

题目描述&#xff1a; 这里有一幅服务器分布图&#xff0c;服务器的位置标识在 m * n 的整数矩阵网格 grid 中&#xff0c;1 表示单元格上有服务器&#xff0c;0 表示没有。 如果两台服务器位于同一行或者同一列&#xff0c;我们就认为它们之间可以进行通信。 请你统计并返回能…

工控机驱动自助检票机,打造轨道交通的智慧未来!

随着城市化进程的加速和人口的不断增长&#xff0c;城市轨道交通建设正日益成为解决交通拥堵、提高交通工作效率的重要举措。然而&#xff0c;仅仅依靠传统的交通设施已经无法满足城市发展的需求&#xff0c;轨道交通智能系统建设成为了不可忽视的发展趋势。 AFC&#xff0c;即…

Git gui教程---第八篇 Git gui的使用 创建一个分支

一般情况下一个主分支下代码稳定的情况下会新建出一个分支&#xff0c;然后在分支上修改&#xff0c;修改完成稳定后再合并到主分支上。 或者几个人合作写一份代码&#xff0c;每个人各一个分支&#xff0c;测试稳定再合并到主分支上。 在git gui选择菜单栏“分支”&#xff0…

Linux之套接字UDP实现网络通信

Linux之套接字UDP实现网络通信 文章目录 Linux之套接字UDP实现网络通信1.引言2.具体实现2.1需要知道的套接字接口1.socket()2.bind()3.recvfrom()4.sendto() 2.2服务器端server.hpp2.3服务器端server.cc2.4客户端Client.cc 1.引言 ​ 套接字(Socket)是计算机网络中实现网络通信…

docker安装clickhouse

安装 docker安装 创建clickhouse目录 mkdir -P /data/clickhouse/datamkdir -P /data/clickhouse/confmkdir -P /data/clickhouse/log 拉取镜像 这里直接拉取最新镜像, 如果需要某个特定版本, 则再拉取的时候指定版本号即可. docker pull clickhouse/clickhouse-server 启动临…

Springboot实现ENC加密

Springboot实现ENC加密 1、导入依赖2、配置加密秘钥&#xff08;盐&#xff09;3、获取并配置密文4、重启项目测试5、自定义前缀、后缀6、自定义加密方式 1、导入依赖 关于版本&#xff0c;需要根据spring-boot版本&#xff0c;自行修改 <dependency><groupId>co…