动态规划应该如何学习?

动态规划如何学习

参考灵神的视频和题解做的笔记(灵神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]);elsedp[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]);elsedp[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];}
};

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

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

相关文章

虚拟化环境中的精简版 Android 操作系统 Microdroid

随着移动设备的普及和应用场景的多样化&#xff0c;安全性和隐私保护成为了移动操作系统的重要课题。Google推出的Microdroid&#xff0c;是一个专为虚拟化环境设计的精简版Android操作系统&#xff0c;旨在提供一个安全、隔离的执行环境。本文将详细介绍Microdroid的架构、功能…

【Docker系列】指定系统平台拉取 openjdk:8 镜像

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…

(七)Python运算符和优先级

一、算数运算符 算数运算符&#xff0c;如下表所示&#xff1a; x1 y2 z3 # 加法运算 axy print(a,a) # 减法运算 by-x print(b,b) # 乘法运算 cy*z print(c,c) # 除法运算 dz/y print(d,d) # 取模运算 ez%y print(e,e) # 幂运算 fy**z print(f,f) 输出结果&#xff1a; 二…

Linux中使用NGINX

NGINX简介 Nginx&#xff08;engine x&#xff09;是俄罗斯人编写的十分轻量级的HTTP服务器是一个高性能的HTTP和反向代理服务器&#xff0c;同时也是一个IMAP/POP3/SMTP代理服务器官方网站&#xff1a;http://nginx.org/ NGINX概述 Nginx默认配置文件&#xff1a;/etc/ngin…

数据结构之线段树

线段树 线段树&#xff08;Segment Tree&#xff09;是一种高效的数据结构&#xff0c;广泛应用于计算机科学和算法中&#xff0c;特别是在处理区间查询和更新问题时表现出色。以下是对线段树的详细解释&#xff1a; 一、基本概念 线段树是一种二叉搜索树&#xff0c;是算法竞…

【C++】继承的理解

1.继承的概念和定义 1.1继承的概念 继承 (inheritance) 机制是面向对象程序设计 使代码可以复用 的最重要的手段&#xff0c;它允许程序员在 保 持原有类特性的基础上进行扩展 &#xff0c;增加功能&#xff0c;这样产生新的类&#xff0c;称派生类。继承 呈现了面向对象 程序…

C++ 详细讲解 洛谷P1428 小鱼比可爱

&#xff08;其实这道题难度不高&#xff0c;但是博主正在适应c语言加上这道题目太可爱了所以忍不住发发~&#xff09; 目录 1.题目要求 2.题目解读 3.代码实现 1.题目要求 2.题目解读 这道题需要使用c中的容器储存小鱼的可爱程度和不如自己可爱的小鱼的数目&#xff0c;…

Android亮屏Job的功耗优化方案

摘要: Job运行时会带来持锁的现象,目前灭屏放电Job的锁托管已经有doze和绿盟标准监管,但是亮屏时仍旧存在过长的持锁现象,故为了优化功耗和不影响用户体验下,新增亮屏放电下如果满足冻结和已运行过一次Job,则进行job限制,当非冻结时恢复的策略 1.现象: (gms_schedu…

Spring1(初始Spring 解耦实现 SpringIOC SpringDI Spring常见面试题)

Spring1 创建项目集成maven创建一个Maven项目实现&#xff1a; 初识SpringSpring简介Spring的发展历史Spring之父体系结构生态系统官方文档解耦实现JDBCSpringBoot整合MyBatis和lombok&#xff0c;开启驼峰映射三层思想 SpringIOC实现 SpringDIset注入全部代码&#xff1a;实现…

服务器新建用户

文章目录 前言一、步骤二、问题三、赋予管理员权限总结 前言 环境&#xff1a; 一、步骤 创建用户需要管理员权限sudo sudo useradd tang为用户设置密码 sudo passwd tang设置密码后&#xff0c;可以尝试使用 su 切换到 tang 用户&#xff0c;确保该用户可以正常使用&#…

leetcode-88-合并两个有序数组

题解&#xff1a; 解法一&#xff1a;从后向前同时遍历两个数组&#xff0c;因为nums1后面是0&#xff0c;从后遍历节省空间。 1、定义三个指针&#xff0c;分别为&#xff1a;len1m-1指向nums1的最后一个非0数字&#xff1b;len2n-1指向nums2的最后一个数字&#xff1b;len3…

操作系统(10) (并发(2)------基于软件/硬件/操作系统层面解决两个进程之间的临界区问题/抢占式/非抢占式内核)

目录 1. 基于软件层面(Petersons Solution) Petersons Solution 满足三个要求: 好处: 缺点 2. 基于硬件层面 1. Disabling Interrupts (禁用中断) 概念解释&#xff1a; 代码框架&#xff1a; 要求&#xff1a; 禁用中断的好处与问题&#xff1a; 2. Test and Set Lock (…

Java | Leetcode Java题解之第526题优美的排列

题目&#xff1a; 题解&#xff1a; class Solution {public int countArrangement(int n) {int[] f new int[1 << n];f[0] 1;for (int mask 1; mask < (1 << n); mask) {int num Integer.bitCount(mask);for (int i 0; i < n; i) {if ((mask & (1…

2024年大厂AI大模型面试题精选与答案解析

前言 随着AI市场&#xff0c;人工智能的爆火&#xff0c;在接下来的金九银十招聘高峰期&#xff0c;各大科技巨头和国有企业将会对AGI人才的争夺展开一场大战&#xff0c;为求职市场注入了新的活力。 为了助力求职者在面试中展现最佳状态&#xff0c;深入理解行业巨头的选拔标…

智能网联汽车:人工智能与汽车行业的深度融合

内容概要 在这个快速发展的时代&#xff0c;智能网联汽车已经不再是科幻电影的专利&#xff0c;它正在悄然走进我们的日常生活。如今&#xff0c;人工智能&#xff08;AI&#xff09;技术与汽车行业的结合犹如一场科技盛宴&#xff0c;让我们看到了未来出行的新方向。通过自动…

AI大模型重塑软件开发:从代码自动生成到智能测试

随着AI技术的不断发展&#xff0c;AI大模型在软件开发领域的应用日益广泛。从代码自动生成到智能测试&#xff0c;AI大模型正在深刻改变着软件开发的各个环节&#xff0c;重塑着整个开发流程。本文将探讨AI大模型的定义、应用场景、优势以及挑战&#xff0c;并展望未来的发展趋…

【基础】os模块

前言 1、os是operation system&#xff08;操作系统&#xff09;的缩写&#xff1b;os模块就是python对操作系统操作接口的封装。os模块提供了多数操作系统的功能接口函数。&#xff08;OS模块提供了与操作系统进行交互的函数&#xff09; 2、操作系统属于Python的标准实用程…

算法学习027 c++蛇形三角形填充 二维数组常规应用 中小学算法思维学习 比赛算法题解 信奥算法解析

目录 C蛇形三角形填充 一、题目要求 1、编程实现 2、输入输出 二、算法分析 三、程序编写 四、运行结果 五、考点分析 六、推荐资料 C蛇形三角形填充 一、题目要求 1、编程实现 输入一个正整数N&#xff0c;输出N行的蛇形数字三角形&#xff08;见输出样例&#xf…

[vulnhub]DC: 1

https://www.vulnhub.com/entry/dc-1,292/ 主机发现端口扫描 使用nmap扫描网段类存活主机 因为靶机是我最后添加的&#xff0c;所以靶机IP是156 nmap -sP 192.168.75.0/24 // Starting Nmap 7.93 ( https://nmap.org ) at 2024-09-28 12:48 CST Nmap scan rep…

PyQt5的安装与简介

目录 一、介绍 二、PyQt5的安装 1、安装PyQt5 2、安装Qt的工具包 三、配置Qt工具 1、配置Designer &#xff08;1)、打开pycharm&#xff0c;找到设置选项 &#xff08;2&#xff09;、找到工具-->外部工具 &#xff08;3&#xff09;、点击号&#xff0c;创建外部工…