动态规划应该如何学习？

动态规划如何学习

参考灵神的视频和题解做的笔记（灵神YYDS，以后也都会用这套逻辑去思考）

枚举选哪个：

动态规划入门：从记忆化搜索到递推_哔哩哔哩_bilibili

746. 使用最小花费爬楼梯 - 力扣（LeetCode）
选或不选：

0-1背包 完全背包_哔哩哔哩_bilibili
494. 目标和 - 力扣（LeetCode）

个人觉得枚举选哪个和选或不选的区别是
枚举选哪个是在回溯函数中有for循环
而选或不选只有两个选择，一般会是二叉树

文章目录

  • 动态规划如何学习
    • 学习步骤：
    • 枚举选哪个
    • 746.使用最小花费爬楼梯
      • 第一步：回溯法（深度优先遍历）
      • 第二步：改成记忆化搜索
      • 第三步：一比一翻译成动态规划(递推)
      • 优化
    • 选或不选
    • 01背包（模板，可以配合该视频和代码随想录博客一起看）
      • 第一步：回溯法（深度优先遍历）
      • 第二步：改成记忆化搜索
      • 第三步：一比一翻译成动态规划(递推)
      • 滚动数组代码

学习步骤：

1.思考递归回溯的暴力穷举法（即深度优先遍历DFS）

注意要画树形结构，画完很容易看出哪里是重复的计算，对改成记忆化搜索有好处

可以使用代码随想录的递归三部曲

2.改成记忆化搜索，就是准备一个备忘录数组，保存已经计算过的结果

3.把记忆化搜索1:1翻译成为DP

翻译的时候可以想想代码随想录的动规五部曲，其实到这里五部曲的内容已经全部解决了

刷了几道题以后的发现：
1.思考回溯的时候一般就会把dp数组和下标的含义给想清楚，这一过程就是分割子问题的过程，不然回溯想不出来的

2.回溯算法终止条件一般是dp数组的初始化

3.记忆化搜索一般是自底向上，和动态规划的从前往后其实是一样的，只是记忆化是递归里的栈，而动态规划是for循环

4.dfs函数就是dp数组

5.dfs一般传入的参数n在动态规划里面一般是一层for循环，dfs中如果有for循环，那动态规划的递推一般是两层循环，而且n可以和循环中的一个进行替换

image-20241028203740524

**动态规划有「选或不选」和「枚举选哪个」两种基本思考方式。**在做题时，可根据题目要求，选择适合题目的一种来思考。

枚举选哪个

746.使用最小花费爬楼梯

746. 使用最小花费爬楼梯 - 力扣（LeetCode）

第一步：回溯法（深度优先遍历）

这个过不了，时间复杂度太高，但是这是学习动态规划的必由之路

思路：

首先思考子问题并画出树形结构图

我们要求到第5个台阶的最小花费，我们可以从第4个加上4的花销上一个台阶，也可以从3加上3的花销上两个台阶

我们要求到第n个台阶的最小花费，我们可以从第n-1个加上n-1的花销上一个台阶，也可以从n-2加上n-2的花销上两个台阶，n-1就是下一个要求的子问题，由n-2和n-3得到，一直到1或2，它的花费就是0，因为可以选择从1或2开始爬楼梯

这样就得到了一个二叉树（以5为例子）

我们要到5的台阶，就要依靠到达4和到达3的结果，来比较得到最小值，所以要得到下层结点向上层返回的结果，那就得用后序遍历来得到4,3的结果

image-20241029105344787

1.返回值和参数

我们要下层结点的最小值，所以要int

cost是题目中的花费数组，index是记录我们遍历到哪里了，相当于for循环里面的i

int dfs(vector<int>& cost,int index)

2.终止条件

if(index==0||index==1)
	return 0;

0其实是第一个台阶，1其实是第二个台阶，因为cost数组从0开始。

爬第一个或第二个台阶不需要花费，所以直接返回0

3.本层逻辑

左子树返回爬上第n-1台阶的最小值

右子树返回爬上第n-2台阶的最小值

最后本层返回的就是两者的最小值作为结果

int l=dfs(cost,index-1)+cost[index-1];
int r=dfs(cost,index-2)+cost[index-2];
return min(l,r);

完整代码：

class Solution {
public:
    int dfs(vector<int>& cost,int index)
    {
        if(index==0||index==1)
            return 0;
        int l=dfs(cost,index-1)+cost[index-1];
        int r=dfs(cost,index-2)+cost[index-2];
        return min(l,r);
    }
    int minCostClimbingStairs(vector<int>& cost) {
        return dfs(cost,cost.size());
    }
};

C++还可用lambda来写

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        function<int(int)> dfs=[&](int index)->int{
            if(index==0||index==1)
                return 0;
            return min(dfs(index-1)+cost[index-1],dfs(index-2)+cost[index-2]);
        };
        return dfs(cost.size());
    }
};

第二步：改成记忆化搜索

000

从图中可以看到，这些地方就是重复计算的地方，可以直接砍掉。

怎么砍呢？

我们在遍历过程中，如果是第一次碰到这个数字呢，我们就把它的计算结果给保存到一个数组当中去，下次要用的话直接从数组里面拿而不用再次进行递归计算了。

砍完之后还剩下啥：只需要计算3,4,5，你会发现时间复杂度竟然变成了O(n)，成了线性的，那这不就和递推一样了么？用1,2计算3，用2,3计算4，用3,4计算5得出结果。

在递归进行记忆化搜索里面，这是自底向上的计算，算5，要去递归3,4，然后一层一层递归

到最后1和2的时候直接返回0，然后得出3的最小，然后根据2,3得出4的最小，最后一层一层返回知道最后。

下面就来看递推。

完整代码：

class Solution {
public:
    int dfs(vector<int>& cost,vector<int>& dp,int index)
    {
        if(index==0||index==1)
            return 0;
        //碰到了算过的，那就直接返回
        if(dp[index]!=-1)
            return dp[index];
        int l=dfs(cost,dp,index-1)+cost[index-1];
        int r=dfs(cost,dp,index-2)+cost[index-2];
        return dp[index]=min(l,r);
        //1.return dp[index]=min(dfs(cost,dp,index-1)+cost[index-1],dfs(cost,dp,index-2)+cost[index-2]);这样写也行
        //2.dp[index]=min(l,r);
        //return dp[index];也行
    }
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size()+1,-1);
        return dfs(cost,dp,cost.size());
    }
};

class Solution {
public:
    
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size()+1,-1);
        function<int(int)> dfs=[&](int index)->int{
            if(index==0||index==1)
                return 0;
            if(dp[index]!=-1)
                return dp[index];
            int& res=dp[index];
            return res=min(dfs(index-1)+cost[index-1],dfs(index-2)+cost[index-2]);
        };
        return dfs(cost.size());
    }
};

注意点：
1.传入的dp备忘录必须是引用传入，不然的话下层的结果保存不到数组里面，每一层的dp数组还全都是-1，就和DFS逻辑一样了其实。dp数组不会起到任何作用

2.对dp[index]一定要赋值，不能直接返回min(l,r)，不然dp数组不会更新

3.l和r不可以替换成dp[index-1]和dp[index-2]。（如果有小伙伴不幸和一样犯了这个错误，那就继续看吧）

int dp[index-1]=dfs(cost,dp,index-1)+cost[index-1];
int dp[index-2]=dfs(cost,dp,index-2)+cost[index-2];
return dp[index]=min(l,r);

我先说答案：这种乍一看挺对的，实际上没有想清楚dfs返回值到底是什么，dfs（index-1）的返回值是dp[index-1]，如果再加上cost[index-1]，那得到的应该是dp[index]，而不是dp[index]。

下面是我没彻底弄懂之前写的，只是记录一下自己的思考过程，不想看的可以跳过了

这种方式会刷新我们已经保存过的dp[index]，就比如起始的0和1，dp[0]和dp[1]花费最小值本来都是0，但是用这个在计算dp[3]的时候会把dp[0]和dp[1]赋值为cost[0]和cost[1]。

然后dp[2]=dp[0]+cost[0]=2，可是我们一看这肯定是1怎么能是2呢？

后面的dp[3]也是最开始被更新为3，后面直接变成4了，这就是再次刷新了

输入
cost =
[1,100,1,1,1,100,1,1,100,1]
标准输出
index=2
1 100 -1 -1 -1 -1 -1 -1 -1 -1 -1 
index=3
1 100 2 -1 -1 -1 -1 -1 -1 -1 -1 
index=4
1 100 3 3 -1 -1 -1 -1 -1 -1 -1 
index=5
1 100 3 4 4 -1 -1 -1 -1 -1 -1 
index=6
1 100 3 4 5 104 -1 -1 -1 -1 -1 
index=7
1 100 3 4 5 204 6 -1 -1 -1 -1 
index=8
1 100 3 4 5 204 7 7 -1 -1 -1 
index=9
1 100 3 4 5 204 7 8 107 -1 -1 
index=10
1 100 3 4 5 204 7 8 207 9 -1

正确的打印：

cost =
[1,100,1,1,1,100,1,1,100,1]
标准输出
index=2
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 
index=3
-1 -1 1 -1 -1 -1 -1 -1 -1 -1 -1 
index=4
-1 -1 1 2 -1 -1 -1 -1 -1 -1 -1 
index=5
-1 -1 1 2 2 -1 -1 -1 -1 -1 -1 
index=6
-1 -1 1 2 2 3 -1 -1 -1 -1 -1 
index=7
-1 -1 1 2 2 3 3 -1 -1 -1 -1 
index=8
-1 -1 1 2 2 3 3 4 -1 -1 -1 
index=9
-1 -1 1 2 2 3 3 4 4 -1 -1 
index=10
-1 -1 1 2 2 3 3 4 4 5 -1

第三步：一比一翻译成动态规划(递推)

1.确定dp数组以及下标的含义

dp数组含义是登上第i个台阶由多少种方法

i下标就是第i+1个台阶

2.确定递推公式

dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);

这个就是在回溯的两个选择里面挑一个小的

就是记忆化搜索里面的返回值

3.dp数组如何初始化

就是回溯里面的终止条件

vector<int> dp(cost.size()+1,-1);
dp[0]=0,dp[1]=0;

4.确定遍历顺序

后面的5要依靠前面3,4的计算结果，所以肯定是正向遍历

完整代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size()+1,-1);
        dp[0]=0,dp[1]=0;
        for(int i=2;i<=cost.size();i++)
            dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        return dp[cost.size()];
    }
};

优化

其实也不需要把所有的结果全都给记住，只需要记住i的前一个i-1（b）和前前一个i-2（a）

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //a=dp[0],b=dp[1]
        int a=0,b=0;
        for(int i=2;i<=cost.size();i++)
        {
            int c=min(a+cost[i-2],b+cost[i-1]);
            a=b;
            b=c;
		} 
        //c=dp[i] a=dp[i-1] b=dp[i]然后下一次循环的时候i++，a就变成dp[i-2],b变成dp[i-1]
        return b;
    }
};

选或不选

0-1背包 完全背包_哔哩哔哩_bilibili

01背包（模板，可以配合该视频和代码随想录博客一起看）

image-20241031120326938

image-20241031125050721

恰好装这个容量，求方案数量的最大最小价值和，那就是把选最大值的操作换成加号

494. 目标和 - 力扣（LeetCode）

后续如果做到了其他的变形题目会同步更新到这里

第一步：回溯法（深度优先遍历）

思路：

配合视频一起看更棒

0-1背包 完全背包_哔哩哔哩_bilibili

image-20241031122300319

下面的就不画了，大家知道这个意思就行

选编号为i的话就是返回dfs(i-1,c-w[i])+v[i]，就是代表已经把编号为i的物品已经放入了背包（表现为容量减了w[i]，价值加了v[i]），然后继续递归下一个物品

不选编号为i的话就是返回dfs(i-1,c)，这个代表的是一共有i-1个物品，总共是c的容量，那背包能装的最大价值是多少

我们本层函数会产生两个递归，一个是选了i，一个是没选i，返回的都是对应情况的最大值，我们要选最大的，所以要在这两个里面再选一个更大的作为返回值返回

从而得出了递推公式。

这个虽然过不了，时间复杂度太高，但是这是学习动态规划的必由之路

1.返回值和参数

w各个物品所占空间

v各个物品价值

i遍历物品

c是当前剩余的容量

返回值返回选或不选编号为i的物品的最大值

int dfs(vector<int>& w,vector<int>& v,int i,int c)

2.终止条件

if(i<0)
	return 0;
if(c<w[i])
	return dfs(w,v,i-1,c);

如果编号小于0说明已经到了树形结构最下面了，要开始从第一个物品选了，即自底（第一个物品）向上（i依次增大）开始遍历

如果当前容量已经小于要选的物品，那就直接返回给上层不选i号物品的结果

3.本层逻辑

在选和不选当前物品两种情况中（只要返回回来的一定是最大值），挑一个更大的返回

return max(dfs(w,v,i-1,c),dfs(w,v,i-1,c-w[i])+v[i]);

完整代码：

class Solution {
public:
    int dfs(vector<int>& w,vector<int>& v,int i,int c)
    {
        if(i<0)
            return 0;
        if(c<w[i])
            return dfs(w,v,i-1,c);
        return max(dfs(w,v,i-1,c),dfs(w,v,i-1,c-w[i])+v[i]);
    }
    int 01knapsack(vector<int>& nums,int c) {
        vector<int> w(nums.begin(),nums.end());
        vector<int> v(nums.begin(),nums.end());
        return dfs(w,v,nums.size()-1,c);
    }
};

C++还可用lambda来写

class Solution {
public:
    int 01knapsack(vector<int>& nums,int c) {
        vector<int> w(nums.begin(),nums.end());
        vector<int> v(nums.begin(),nums.end());
        function<int(int,int)> dfs=[&](int i,int c)->int{
            if(i<0)
                return 0;
            if(c<w[i])
                return dfs(i-1,c);
            return max(dfs(i-1,c),dfs(i-1,c-w[i])+v[i]);
        };
        return dfs(nums.size()-1,c);
    }
};

第二步：改成记忆化搜索

注意，在递归函数中，我们同时有物品编号i和容量c，所以要用一个二维数组作为哈希表来存储计算结果进行复用。

然后在每次返回结果前都赋值一下，把计算结果给存储起来

完整代码：

class Solution {
public:
	int dfs(vector<int>& w,vector<int>& v,int i,int c,vector<vector<int>>& dp)
    {
        if(i<0)
            return 0;
        if(dp[i][c]!=-1)
            return dp[i][c];
        if(c<w[i])
            return dp[i][c]=dfs(w,v,i-1,c,dp);
        return dp[i][c]=max(dfs(w,v,i-1,c,dp),dfs(w,v,i-1,c-w[i],dp)+v[i]);
    }
    int 01knapsack(vector<int>& nums,int c) {
        vector<int> w(nums.begin(),nums.end());
        vector<int> v(nums.begin(),nums.end());
        vector<vector<int>> dp(nums.size(),vector<int>(c+1,-1));
        return dfs(w,v,nums.size()-1,c,dp);
    }
};

class Solution {
public:
    int 01knapsack(vector<int>& nums,int c) {
        vector<int> w(nums.begin(),nums.end());
        vector<int> v(nums.begin(),nums.end());
        vector<vector<int>> dp(nums.size(),vector<int>(c+1,-1));
        function<int(int,int)> dfs=[&](int i,int c)->int{
            if(i<0)
            return 0;
            if(dp[i][c]!=-1)
                return dp[i][c];
            if(c<w[i])
                return dp[i][c]=dfs(i-1,c);
            return dp[i][c]=max(dfs(i-1,c),dfs(i-1,c-w[i])+v[i]);
        };
        return dfs(nums.size()-1,c);
    }
};

第三步：一比一翻译成动态规划(递推)

1.确定dp数组以及下标的含义

二维数组，dp[i][c]就是第i个物品在容量为c时可以取到的最大价值

i是物品编号

c是当前背包的总容量

2.确定递推公式

对应回溯算法本层逻辑部分

选或者不选第i号物品，如果没选，那就和上一个物品第i-1件遍历到j时一样的价值，因为没有选第i号

如果选了那就是 第i-1件物品在j-w[i]时的价值+选择的第i件物品的价值v[i]

dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);

3.dp数组如何初始化

全都初始化为0

第一行在容量大于第一件物品所需容量的时候就当做把第一件给放了进行初始化

因为dp[0][i]的物品编号只有0，即第一件物品，所以只能选择第一件物品得到最大价值，不选的话价值就为0

vector<vector<int>> dp(nums.size(),vector<int>(c+1,0));
for(int i=w[0];i<=c;i++)
	dp[0][i]=v[0];

4.确定遍历顺序

20240730174246

20240730174436

从前往后遍历，先遍历物品或者先遍历容量都是可以的，因为先物品是按照行一行一行来遍历，递推公式中的两个值都可以在遍历得出来，按照容量一列一列遍历也同样可以得出来这两个值

但仅限于二维，如果是一维那就只能先遍历物品后遍历容量，而且只能从后往前遍历容量

因为递推公式中用到的两个值在一维中变成了这样：

vector<int> dp(c+1,0);
for(int i=0;i<nums.size();i++)
	for(int j=c;j>=w[i];j--)
		dp[j]=max(dp[j],dp[j-w[i]]+v[i]);

image-20241031155145293

第一行是刷新前的数组，第二行是要对第一行进行覆盖的值，通过第一行的dp[j]和dp[j-w[i]]这两个值进行更新

如果从前往后，那dp[j-w[i]]就会被覆盖，从而得到一个错误的答案

如果不太理解可以转至：代码随想录

0-1背包 完全背包_哔哩哔哩_bilibili视频里面也会讲到滚动数组相关

for(int i=1;i<nums.size();i++)
for(int j=0;j<=c;j++)
	if(j>w[i])
		dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);
	else
    	dp[i][j]=dp[i-1][j];

完整代码：

class Solution {
public:
    int 01knapsack(vector<int>& nums,int c) {
        vector<int> w(nums.begin(),nums.end());
        vector<int> v(nums.begin(),nums.end());
        vector<vector<int>> dp(nums.size(),vector<int>(c+1,0));
        for(int i=w[0];i<=c;i++)
            dp[0][i]=v[0];
        for(int i=1;i<nums.size();i++)
            for(int j=0;j<=c;j++)
                if(j>w[i])
                    dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);
                else
                    dp[i][j]=dp[i-1][j];
        return dp[w.size()-1][c];
    }
};

滚动数组代码

class Solution {
public:
    int 01knapsack(vector<int>& nums,int c) {
        vector<int> w(nums.begin(),nums.end());
        vector<int> v(nums.begin(),nums.end());
        vector<int> dp(c+1,0);
        for(int i=0;i<nums.size();i++)
            for(int j=c;j>=w[i];j--)
                dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
        return dp[c];
    }
};

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

RK3588的QT交叉编译环境搭建

RK3588的QT交叉编译环境搭建

主要参考为RK3568或RK3288开发板创建交叉编译环境{采用amd64的ubuntu系统配置交叉编译arm64开发环境}(保姆级包括安装QT)超详细记录版_rk3568交叉编译-CSDN博客 先说一下&#xff0c;使用的Ubuntu20.04.5版本&#xff0c;qt源码用的5.14.2版本&#xff0c;交叉编译器使用RK3588…
阅读更多...
专利生成穿刺demo

专利生成穿刺demo

一、做原型 做原型&#xff1f;具体需求是啥&#xff1f;只有一个“帮助客户生成专利说明书”这样一个笼统的要求&#xff1f; 只有这些肯定是不能用来指导原型开发的。既然目前没有准确的需求&#xff0c;那就先看看现有的产品现状吧。 1.竞品分析 怎么开展哪&#xff1f;…
阅读更多...
数字信号处理Python示例（3）生成三相正弦信号

数字信号处理Python示例（3）生成三相正弦信号

文章目录 前言一、三相正弦信号的表示二、生成三相正弦信号的Python代码三、三相正弦信号的图示与分析四、生成幅度不相等的三相正弦信号的Python代码五、幅度不相等的三相正弦信号的图示与分析写在后面的话 前言 首先给出三相正弦信号的数学表达式&#xff0c;并给出生成三相…
阅读更多...
【linux 多进程并发】0302 Linux下多进程模型的网络服务器架构设计，实时响应多客户端请求

【linux 多进程并发】0302 Linux下多进程模型的网络服务器架构设计，实时响应多客户端请求

0302 多进程网络服务器架构 ​专栏内容&#xff1a; postgresql使用入门基础手写数据库toadb并发编程 个人主页&#xff1a;我的主页 管理社区&#xff1a;开源数据库 座右铭&#xff1a;天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物. 一、概…
阅读更多...
Linux云计算 |【第五阶段】CLOUD-DAY9

Linux云计算 |【第五阶段】CLOUD-DAY9

主要内容&#xff1a; Metrics资源利用率监控、存储卷管理&#xff08;临时卷ConfitMap、EmptyDir、持久卷HostPath、NFS(PV/PVC)&#xff09; 一、Metrics介绍 metrics是一个监控系统资源使用的插件&#xff0c;可以监控Node节点上的CPU、内存的使用率&#xff0c;或Pod对资…
阅读更多...
Kafka 判断一个节点是否还活着有那两个条件？

Kafka 判断一个节点是否还活着有那两个条件？

大家好&#xff0c;我是锋哥。今天分享关于【Kafka 判断一个节点是否还活着有那两个条件&#xff1f;】面试题&#xff1f;希望对大家有帮助&#xff1b; Kafka 判断一个节点是否还活着有那两个条件&#xff1f; 1000道 互联网大厂Java工程师 精选面试题-Java资源分享网 在Ka…
阅读更多...
PyQt5实战——多脚本集合包，UI以及工程布局（二）

PyQt5实战——多脚本集合包，UI以及工程布局（二）

个人博客&#xff1a;苏三有春的博客 系列往期&#xff1a; PyQt5实战——多脚本集合包&#xff0c;前言与环境配置&#xff08;一&#xff09; 布局 2.1 UI页面布局 整体框架分为分为三个部分&#xff0c;垂直分布。 第一个部分为功能选择按钮&#xff08;如UTF-8转换&#…
阅读更多...
Cpp::set map 的理解与使用(22)

Cpp::set map 的理解与使用(22)

文章目录 前言一、预备知识关联式容器键值对 二、set何为set?set的使用set的特点multiset 三、map何为map?map中的operator[ ]multimap 总结 前言 刚学完二叉搜索树&#xff0c;我们马上来感受一下直接与它相关的两个容器吧&#xff01; 一、预备知识 关联式容器 在以往的 S…
阅读更多...
PostgreSQL 学习笔记：PostgreSQL 主从复制

PostgreSQL 学习笔记：PostgreSQL 主从复制

PostgreSQL 笔记&#xff1a;PostgreSQL 主从复制 博客地址&#xff1a;TMDOG 的博客 在现代应用程序中&#xff0c;数据库的高可用性和扩展性是至关重要的。PostgreSQL 提供了主从复制功能&#xff0c;可以在多个数据库实例之间复制数据&#xff0c;以实现冗余和负载均衡。本…
阅读更多...
SQL，力扣题目1225，报告系统状态的连续日期【窗口函数】

SQL，力扣题目1225，报告系统状态的连续日期【窗口函数】

一、力扣链接 LeetCode_1225 二、题目描述 表&#xff1a;Failed ----------------------- | Column Name | Type | ----------------------- | fail_date | date | ----------------------- 该表主键为 fail_date (具有唯一值的列)。 该表包含失败任务的天数.表…
阅读更多...
晶台施密特触发器光耦KLH11LX，1MHz高传输速率

晶台施密特触发器光耦KLH11LX，1MHz高传输速率

晶台推出KLH11LX系列由一个砷化镓红外发光二极管和一个高速集成电路检测器组成&#xff0c;该输出检测器包含了一个施密特触发器&#xff0c;利用其回滞特性&#xff0c;便于脉冲整形&#xff0c;提高抗噪性能。 功能图Functional Diagram 产品特点Product Features •高传输…
阅读更多...
Mac在Typora配置PicGo图床,以github为例

Mac在Typora配置PicGo图床,以github为例

Mac配置PicGo图床 0.准备阶段&#xff1a;下载PicGo https://picgo.github.io/PicGo-Doc/zh/guide/ 根据这个链接选择自己的安装方式 1.PicGo已损坏&#xff0c;无法打开 解决方法 打开iTerm,把sudo xattr -d com.apple.quarantine 输入命令行 然后把软件拖入命令行 sudo xa…
阅读更多...
「Mac畅玩鸿蒙与硬件23」鸿蒙UI组件篇13 - 自定义组件的创建与使用

「Mac畅玩鸿蒙与硬件23」鸿蒙UI组件篇13 - 自定义组件的创建与使用

自定义组件可以帮助开发者实现复用性强、逻辑清晰的界面模块。通过自定义组件，鸿蒙应用能够提高代码的可维护性，并简化复杂布局的构建。本篇将介绍如何创建自定义组件，如何向组件传递数据，以及如何在不同页面间复用这些组件。 关键词 自定义组件复用组件属性传递组件通信组…
阅读更多...
redis模板的应用：自定义redisTemplate序列化规则 （RedisTemplate和StringRedisTemplate）

redis模板的应用：自定义redisTemplate序列化规则 （RedisTemplate和StringRedisTemplate）

文章目录 引言I 基础知识redis对key和value使用序列化方式RedisTemplate<Object, Object>自定义redisTemplate序列化规则RedisTemplate<String, String>II 存储自定义对象redisTemplate存储自定义对象StringRedisTemplate存储自定义对象引言 StringRedisTemplate只…
阅读更多...
二叉苹果树

二叉苹果树

AcWing 1074. 二叉苹果树【有依赖背包DP】 - AcWing 问题描述 在一棵有权无向树中&#xff0c;从某个节点&#xff08;这里假设为节点 1&#xff09;出发&#xff0c;遍历树的子节点&#xff0c;每经过一条边会获得对应的权重值。在访问节点数的限制下&#xff08;即体积限制…
阅读更多...
Linux基础命令（八） 之 alias ，history，stat，type，特殊符号及命令行快捷键

Linux基础命令（八） 之 alias ，history，stat，type，特殊符号及命令行快捷键

目录 一&#xff0c;命令别名 alias 常见用法 二&#xff0c;命令历史 history 参数及其作用 常见用法 三.显示文件或文件系统的详细信息 stat 参数及其作用 常见用法 四&#xff0c;显示命令的类型 type 参数及其作用 常见用法 五&#xff0c;特殊符号及命令行快捷…
阅读更多...
省级-知识产权保护指数（2012-2022年）

省级-知识产权保护指数（2012-2022年）

省级知识产权保护指数&#xff08;以下简称“指数”&#xff09;正是衡量各省份在知识产权保护方面表现的一个综合指标&#xff0c;它涵盖了立法、执法、审查和监督等多个维度&#xff0c;全面反映了各省份在知识产权保护方面的综合实力。 2012年-2022年省级-知识产权保护指数…
阅读更多...
GraphQL 与 Elasticsearch 相遇：使用 Hasura DDN 构建可扩展、支持 AI 的应用程序

GraphQL 与 Elasticsearch 相遇：使用 Hasura DDN 构建可扩展、支持 AI 的应用程序

作者&#xff1a;来自 Elastic Praveen Durairaju GraphQL 提供了一种高效且灵活的数据查询方式。本博客将解释 Hasura DDN 如何与 Elasticsearch 配合使用&#xff0c;以实现高性能和元数据驱动的数据访问。 此示例的代码和设置可在此 GitHub 存储库 - elasticsearch-subgraph…
阅读更多...
filebeat+elasticsearch+kibana日志分析

filebeat+elasticsearch+kibana日志分析

1 默认配置 1.1 filebeat filebeat-7.17.yml,从网关中下载k8s的配置&#xff0c;指定es和kibana的配置 通过kibana查询可以查询到日志了&#xff0c;但此时还不知道具体怎么用。 1.2 kibana 在Discover中创建索引格式&#xff1a;filebeat-*&#xff0c;得到如下图&#xf…
阅读更多...
Rust 力扣 - 2090. 半径为 k 的子数组平均值

Rust 力扣 - 2090. 半径为 k 的子数组平均值

文章目录 题目描述题解思路题解代码题目链接 题目描述 题解思路 半径为 k 的子数组平均值 等价于 子数组长度为2 * k 1的总和 除于 2 * k 1 我们遍历长度为2 * k 1的窗口&#xff0c;我们只需要记录窗口内的平均值即可 题解代码 impl Solution {pub fn get_averages(num…
阅读更多...
最新文章

Copyright @ 2022~2023