代码随想录Day 38|背包问题完结，题目322.零钱兑换、279.完全平方数、139，单词拆分数

news2024/9/23 15:22:29

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

  • 动态规划part06
  • 题目
    • 题目一：322. 零钱兑换
      • 解题思路：
      • 题目二：279.完全平方数
      • 题目三：139.单词拆分数
      • 解题思路：
      • 背包问题
  • 多重背包（了解）
  • 背包问题总结

动态规划part06

背包问题完结

题目

题目一：322. 零钱兑换

322. 零钱兑换

解题思路：

在518.零钱兑换II 中我们已经兑换一次零钱了，这次又要兑换，套路不一样！

题目中说每种硬币的数量是无限的，可以看出是典型的完全背包问题。

动规五部曲分析如下：

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

​ dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

  1. 确定递推公式

​ 凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）

​ 所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。

​ 递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

  1. dp数组如何初始化

​ 在解决完全背包问题时，初始化 dp[0] 为 0 表示凑成金额 0 不需要硬币，而其他金额 dp[j] 应初始化为最大值，以确保在递推过程中正确更新为最小硬币数量，避免被错误的初始值覆盖。

代码如下：

vector<int> dp(amount + 1, INT_MAX);
dp[0] = 0;
  1. 确定遍历顺序

在解决钱币兑换问题时，目标是找出组成特定金额的最小钱币数量，而不是关心钱币的排列顺序。

因此，无论是处理组合还是排列，关键在于如何有效地遍历和更新动态规划数组。

对于本题，选择将钱币（物品）作为外层循环，目标金额（背包容量）作为内层循环。由于每种钱币可以无限使用，这是一个完全背包问题，内层循环按正序进行更新。

总结：我们通过外层循环遍历钱币，内层循环遍历金额，正序更新动态规划数组，以求得组成特定金额的最小钱币数量。这种方法适用于完全背包问题，确保了算法的正确性和效率。

  1. 举例推导dp数组

以输入：coins = [1, 2, 5], amount = 5为例

322.零钱兑换

dp[amount]为最终结果。

以上分析完毕，C++ 代码如下：

// 版本一
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i < coins.size(); i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                if (dp[j - coins[i]] != INT_MAX) { // 如果dp[j - coins[i]]是初始值则跳过
                    dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};
  • 时间复杂度: O(n * amount)，其中 n 为 coins 的长度
  • 空间复杂度: O(amount)

对于遍历方式遍历背包放在外循环，遍历物品放在内循环也是可以的，代码如下：

// 版本二
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 1; i <= amount; i++) {  // 遍历背包
            for (int j = 0; j < coins.size(); j++) { // 遍历物品
                if (i - coins[j] >= 0 && dp[i - coins[j]] != INT_MAX ) {
                    dp[i] = min(dp[i - coins[j]] + 1, dp[i]);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};
  • 时间复杂度: O(n * amount)，其中 n 为 coins 的长度
  • 空间复杂度: O(amount)

题目二：279.完全平方数

279. 完全平方数

解题思路：

题目翻译一下：完全平方数就是物品（可以无限件使用），凑个正整数n就是背包，问凑满这个背包最少有多少物品？

感受浓厚的完全背包氛围，而且和322. 零钱兑换是一样的解题思路。

动规五部曲分析如下：

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

dp[j]：和为j的完全平方数的最少数量为dp[j]

  1. 确定递推公式

dp[j] 可以由dp[j - i * i]推出， dp[j - i * i] + 1 便可以凑成dp[j]。

此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j]);

  1. dp数组如何初始化

dp[0]表示 和为0的完全平方数的最小数量，那么dp[0]一定是0。

有同学问题，那0 * 0 也算是一种啊，为啥dp[0] 就是 0呢？

看题目描述，找到若干个完全平方数（比如 1, 4, 9, 16, …），题目描述中可没说要从0开始，dp[0]=0完全是为了递推公式。

非0下标的dp[j]应该是多少呢？

从递归公式dp[j] = min(dp[j - i * i] + 1, dp[j]);中可以看出每次dp[j]都要选最小的，所以非0下标的dp[j]一定要初始为最大值，这样dp[j]在递推的时候才不会被初始值覆盖。

  1. 确定遍历顺序

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

所以本题外层for遍历背包，内层for遍历物品，还是外层for遍历物品，内层for遍历背包，都是可以的！

外层遍历背包，内层遍历物品的代码：

vector<int> dp(n + 1, INT_MAX);
dp[0] = 0;
for (int i = 0; i <= n; i++) { // 遍历背包
    for (int j = 1; j * j <= i; j++) { // 遍历物品
        dp[i] = min(dp[i - j * j] + 1, dp[i]);
    }
}
  1. 举例推导dp数组

已输入n为5例，dp状态图如下：

279.完全平方数

dp[0] = 0 dp[1] = min(dp[0] + 1) = 1 dp[2] = min(dp[1] + 1) = 2 dp[3] = min(dp[2] + 1) = 3 dp[4] = min(dp[3] + 1, dp[0] + 1) = 1 dp[5] = min(dp[4] + 1, dp[1] + 1) = 2

最后的dp[n]为最终结果。

以上动规五部曲分析完毕C++代码如下：

// 版本一
class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i <= n; i++) { // 遍历背包
            for (int j = 1; j * j <= i; j++) { // 遍历物品
                dp[i] = min(dp[i - j * j] + 1, dp[i]);
            }
        }
        return dp[n];
    }
};
  • 时间复杂度: O(n * √n)
  • 空间复杂度: O(n)

先遍历物品，在遍历背包的代码，一样的可以AC的。

// 版本二
class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 1; i * i <= n; i++) { // 遍历物品
            for (int j = i * i; j <= n; j++) { // 遍历背包
                dp[j] = min(dp[j - i * i] + 1, dp[j]);
            }
        }
        return dp[n];
    }
};
  • 时间复杂度: O(n * √n)
  • 空间复杂度: O(n)

题目三：139.单词拆分数

139. 单词拆分

解题思路：

回溯算法：分割回文串 ：是枚举分割后的所有子串，判断是否回文。

本道是枚举分割所有字符串，判断是否在字典里出现过。

回溯法C++代码：

class Solution {
private:
    bool backtracking (const string& s, const unordered_set<string>& wordSet, int startIndex) {
        if (startIndex >= s.size()) {
            return true;
        }
        for (int i = startIndex; i < s.size(); i++) {
            string word = s.substr(startIndex, i - startIndex + 1);
            if (wordSet.find(word) != wordSet.end() && backtracking(s, wordSet, i + 1)) {
                return true;
            }
        }
        return false;
    }
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        return backtracking(s, wordSet, 0);
    }
};
  • 时间复杂度：O(2^n)，因为每一个单词都有两个状态，切割和不切割
  • 空间复杂度：O(n)，算法递归系统调用栈的空间

递归的过程中有很多重复计算，可以使用数组保存一下递归过程中计算的结果。

这个叫做记忆化递归，这种方法之前已经提过很多次了。

使用memory数组保存每次计算的以startIndex起始的计算结果，如果memory[startIndex]里已经被赋值了，直接用memory[startIndex]的结果。

C++代码如下：

class Solution {
private:
    bool backtracking (const string& s,
            const unordered_set<string>& wordSet,
            vector<bool>& memory,
            int startIndex) {
        if (startIndex >= s.size()) {
            return true;
        }
        // 如果memory[startIndex]不是初始值了，直接使用memory[startIndex]的结果
        if (!memory[startIndex]) return memory[startIndex];
        for (int i = startIndex; i < s.size(); i++) {
            string word = s.substr(startIndex, i - startIndex + 1);
            if (wordSet.find(word) != wordSet.end() && backtracking(s, wordSet, memory, i + 1)) {
                return true;
            }
        }
        memory[startIndex] = false; // 记录以startIndex开始的子串是不可以被拆分的
        return false;
    }
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        vector<bool> memory(s.size(), 1); // -1 表示初始化状态
        return backtracking(s, wordSet, memory, 0);
    }
};

这个时间复杂度其实也是：O(2^n)。只不过对于上面那个超时测试用例优化效果特别明显。

背包问题

单词就是物品，字符串s就是背包，单词能否组成字符串s，就是问物品能不能把背包装满。

拆分时可以重复使用字典中的单词，说明就是一个完全背包！

动规五部曲分析如下：

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

dp[i] : 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。

  1. 确定递推公式

如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。（j < i ）。

所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。

  1. dp数组如何初始化

从递推公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递推的根基，dp[0]一定要为true，否则递推下去后面都都是false了。

那么dp[0]有没有意义呢？

dp[0]表示如果字符串为空的话，说明出现在字典里。

但题目中说了“给定一个非空字符串 s” 所以测试数据中不会出现i为0的情况，那么dp[0]初始为true完全就是为了推导公式。

下标非0的dp[i]初始化为false，只要没有被覆盖说明都是不可拆分为一个或多个在字典中出现的单词。

  1. 确定遍历顺序

要将一个给定的字符串拆分成字典中存在的单词。这类似于完全背包问题，因为单词可以被重复使用。关键在于确定双层循环的顺序：

  1. 求组合数：我们先遍历单词（物品），再考虑如何将它们组合进字符串（背包）。
  2. 求排列数：我们先确定字符串中的位置（背包），再选择适当的单词（物品）来填充这些位置。

对于本题，关注的是单词的排列顺序，因为不同的排列可能意味着不同的结果。例如，使用单词 “apple” 和 “pen” 来组成 “applepenapple”，必须按照 “apple” + “pen” + “apple” 的顺序来排列单词。因此，我们应该先遍历字符串确定当前处理的子串，然后根据这个子串去选择匹配的单词。

这种方法确保我们能够正确处理单词的顺序，从而找到所有可能的排列方式。

本题需要先确定字符串的分割位置（背包），再选择合适的单词来填充这些位置（物品）。

  1. 举例推导dp[i]

以输入: s = “leetcode”, wordDict = [“leet”, “code”]为例，dp状态如图：

139.单词拆分

dp[s.size()]就是最终结果。

动规五部曲分析完毕，C++代码如下：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> wordSet(wordDict.begin(), wordDict.end());
        vector<bool> dp(s.size() + 1, false);
        dp[0] = true;
        for (int i = 1; i <= s.size(); i++) {   // 遍历背包
            for (int j = 0; j < i; j++) {       // 遍历物品
                string word = s.substr(j, i - j); //substr(起始位置，截取的个数)
                if (wordSet.find(word) != wordSet.end() && dp[j]) {
                    dp[i] = true;
                }
            }
        }
        return dp[s.size()];
    }
};
  • 时间复杂度：O(n^3)，因为substr返回子串的副本是O(n)的复杂度（这里的n是substring的长度）
  • 空间复杂度：O(n)

多重背包（了解）

有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。

多重背包和01背包是非常像的， 为什么和01背包像呢？

每件物品最多有Mi件可用，把Mi件摊开，其实就是一个01背包问题了。

例如：

背包最大重量为10。

物品为：

重量价值数量
物品01152
物品13203
物品24302

问背包能背的物品最大价值是多少？

和如下情况有区别么？

重量价值数量
物品01151
物品01151
物品13201
物品13201
物品13201
物品24301
物品24301

毫无区别，这就转成了一个01背包问题了，且每个物品只用一次。

练习题目：卡码网第56题，多重背包(opens new window)

代码如下：

// 超时了
#include<iostream>
#include<vector>
using namespace std;
int main() {
    int bagWeight,n;
    cin >> bagWeight >> n;
    vector<int> weight(n, 0); 
    vector<int> value(n, 0);
    vector<int> nums(n, 0);
    for (int i = 0; i < n; i++) cin >> weight[i];
    for (int i = 0; i < n; i++) cin >> value[i];
    for (int i = 0; i < n; i++) cin >> nums[i];    
    
    for (int i = 0; i < n; i++) {
        while (nums[i] > 1) { // 物品数量不是一的，都展开
            weight.push_back(weight[i]);
            value.push_back(value[i]);
            nums[i]--;
        }
    }
 
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品，注意此时的物品数量不是n
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

提交之后，发现这个解法超时了，为什么呢，哪里耗时呢？

耗时就在 这段代码：

for (int i = 0; i < n; i++) {
    while (nums[i] > 1) { // 物品数量不是一的，都展开
        weight.push_back(weight[i]);
        value.push_back(value[i]);
        nums[i]--;
    }
}

如果物品数量很多的话，C++中，这种操作十分费时，主要消耗在vector的动态底层扩容上。（其实这里也可以优化，先把 所有物品数量都计算好，一起申请vector的空间。

这里也有另一种实现方式，就是把每种商品遍历的个数放在01背包里面在遍历一遍。

代码如下：（详看注释）

#include<iostream>
#include<vector>
using namespace std;
int main() {
    int bagWeight,n;
    cin >> bagWeight >> n;
    vector<int> weight(n, 0);
    vector<int> value(n, 0);
    vector<int> nums(n, 0);
    for (int i = 0; i < n; i++) cin >> weight[i];
    for (int i = 0; i < n; i++) cin >> value[i];
    for (int i = 0; i < n; i++) cin >> nums[i];

    vector<int> dp(bagWeight + 1, 0);

    for(int i = 0; i < n; i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            // 以上为01背包，然后加一个遍历个数
            for (int k = 1; k <= nums[i] && (j - k * weight[i]) >= 0; k++) { // 遍历个数
                dp[j] = max(dp[j], dp[j - k * weight[i]] + k * value[i]);
            }
        }
    }

    cout << dp[bagWeight] << endl;
}
  • 时间复杂度：O(m × n × k)，m：物品种类个数，n背包容量，k单类物品数量

从代码里可以看出是01背包里面在加一个for循环遍历一个每种商品的数量。 和01背包还是如出一辙的。

当然还有那种二进制优化的方法，其实就是把每种物品的数量，打包成一个个独立的包。

小结：

在准备面试时，重点掌握01背包问题和完全背包问题，对多重背包有一个基本的了解和编码能力。对于更复杂的背包问题变种，如果时间允许，可以作为扩展知识学习，但它们不是面试的关键点。

背包问题总结

关于这几种常见的背包，其关系如下：

416.分割等和子集1

通过这个图，可以很清晰分清这几种常见背包之间的关系。

在讲解背包问题的时候，我们都是按照如下五部来逐步分析，相信大家也体会到，把这五部都搞透了，算是对动规来理解深入了。

  1. 确定dp数组（dp table）以及下标的含义
  2. 确定递推公式
  3. dp数组如何初始化
  4. 确定遍历顺序
  5. 举例推导dp数组

这五部里哪一步都很关键，但确定递推公式和确定遍历顺序都具有规律性和代表性

递归公式：

  1. 能否装满背包或最多装多少：用 dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]) 更新，如分割等和子集和最后一块石头的重量 II。
  2. 装满背包的方法数：用 dp[j] += dp[j - nums[i]] 更新，如目标和和零钱兑换 II。
  3. 装满背包的最大价值：用 dp[j] = max(dp[j], dp[j - weight[i]] + value[i]) 更新，如一和零。
  4. 装满背包所有物品的最小个数：用 dp[j] = min(dp[j - coins[i]] + 1, dp[j]) 更新，如零钱兑换和完全平方数。

遍历顺序：

  • 01背包：二维 dp 可以任意遍历，一维 dp 必须先物品后背包，且从大到小遍历。
  • 完全背包：纯问题中，先物品或先背包都可以，从小到大遍历。但若有变化（如求排列数），外层循环应遍历背包，内层遍历物品。

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

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

相关文章

基于 YOLOv5 的积水检测系统：打造高效智能的智慧城市应用

基于 YOLOv5 的积水检测系统：打造高效智能的智慧城市应用

在城市发展中&#xff0c;积水问题日益严重&#xff0c;特别是在大雨过后&#xff0c;积水往往会影响交通甚至威胁人们的安全。通过现代计算机视觉技术&#xff0c;我们能够智能化地检测和识别积水区域&#xff0c;减少潜在危险。本文将介绍如何使用 YOLOv5 和 PyQt5 搭建一个积…
阅读更多...
Unity使用自定义类型作为字典Key的最佳实践与避坑指南

Unity使用自定义类型作为字典Key的最佳实践与避坑指南

自定义类型作为字典Key的最佳实践与避坑指南文章首发 问题背景 首先提一下之前项目开发时遇到的一个将自定义类型作为Dictionary键的坑。 项目中&#xff0c;我们有两个业务类BusinessA和BusinessB&#xff0c;因为某个需求&#xff0c;我们需要将这两个类建立一个映射关系&…
阅读更多...
游泳馆收银系统源码解析之手牌管理--SAAS本地化及未来之窗行业应用跨平台架构

游泳馆收银系统源码解析之手牌管理--SAAS本地化及未来之窗行业应用跨平台架构

一、代码 if(手牌状态 "空"){结算界面 "";未来之窗_人工智能_通用页面_尺寸(title"游泳馆",收费,500,300);}else{未来之窗_人工智能_通用页面_尺寸(title"游泳馆",退款,1200,500);} 二、阿雪技术观 拥抱开源与共享&#xff0c;见…
阅读更多...
探索图论中的关键算法（Java 实现）

探索图论中的关键算法（Java 实现）

“日出东海落西山 愁也一天 喜也一天 遇事不钻牛角尖” 文章目录 前言文章有误敬请斧正 不胜感恩&#xff01;||Day031. 最短路径算法Dijkstra算法Java 实现&#xff1a; Bellman-Ford算法Java 实现&#xff1a; 2. 最小生成树算法Prim算法Java 实现&#xff1a; Kruskal算法Ja…
阅读更多...
AI基础 L9 Local Search II 局部搜索

AI基础 L9 Local Search II 局部搜索

Local Beam search 对于当前的所有k个状态&#xff0c;生成它们的所有可能后继状态。 检查生成的后继状态中是否有任何状态是解决方案。 如果所有后继状态都不是解决方案&#xff0c;则从所有后继状态中选择k个最佳状态。 当达到预设的迭代次数或满足某个终止条件时&#x…
阅读更多...
读软件设计的要素05概念的特性

读软件设计的要素05概念的特性

1. 概念的特性 1.1. 专一性原则(specificity principle)认为概念与目的应该一一对应 1.1.1. 专一性原则已被证明是概念设计中最有用的原则之一 1.1.2. 一个概念最多只能满足一个目的 1.2. 很少有没有目的的概念 1.2.1. 如果本应隐藏的用户机制被暴露&#xff0c;可能会产生…
阅读更多...
通信工程学习：什么是2ASK/BASK二进制振幅键控

通信工程学习：什么是2ASK/BASK二进制振幅键控

2ASK/BASK&#xff1a;二进制振幅键控 2ASK/BASK二进制振幅键控是一种数字调制技术&#xff0c;其全称是二进制振幅键控&#xff08;Binary Amplitude Shift Keying&#xff09;。该技术通过改变载波的振幅来传递二进制数字信息&#xff0c;而载波的频率和相位则保持不变。以下…
阅读更多...
RISC-V （九）抢占式多任务

RISC-V （九）抢占式多任务

主要的思想&#xff1a;借用定时器中断实现。设置定时器寄存器&#xff0c;系统自动触发定时器中断时会跳到trap handler这个函数里。借用这个函数做上下文的切换&#xff0c;从而实现了抢占式多任务。 定时器中断&#xff1a;跳到trap handler函数&#xff0c;同时系统自动将…
阅读更多...
清华计算几何--凸Polygon的相交问题

清华计算几何--凸Polygon的相交问题

凸Polygon和相交定义 本节只讨论凸Polygon的问题&#xff0c;不涉及凹Polygon. 相交包含了边相交和完全包含。 凸Polygon相交的两个问题 Detection(检测) 判断两个凸Polygon是否相交&#xff0c;至于相交部分是什么不关心. Construction(构造) 求出两个凸Polygon具体相交…
阅读更多...
Linux_kernel移植rootfs10

Linux_kernel移植rootfs10

一、动态更改内核 1、low level&#xff08;静态修改&#xff09; 【1】将led_drv.c拷贝到kernel/drivers/char/目录中 【2】修改当前目录下的Makefile文件 obj-y led_drv.o #将新添加的驱动文件加入到Makefile文件中 【3】退回kernel目录&#xff0c;执行make uImage …
阅读更多...
熬夜后补救措施

熬夜后补救措施

人体的肝功能问题 直接体现在体态和容颜上 伤肝 三大坏行为 熬夜后补救 *补充养b族、口、、锌、硒 加强代谢 能力 (1)另外熬夜后一定要多喝水 提升身体代谢能力 (2)谷肤甘肽清肝 肝脏排毒&#xff0c;减轻负拒 (3)水飞前含量高点 &#xff08;4)熬夜出更多油 容易长痘 需要清…
阅读更多...
标准库标头 ＜filesystem＞ (C++17)学习之文件类型

标准库标头 ＜filesystem＞ (C++17)学习之文件类型

本篇介绍filesystem文件库的文件类型API。 文件类型 is_block_file (C17) 检查给定的路径是否表示块设备 (函数) is_character_file (C17) 检查给定的路径是否表示字符设备 (函数) is_directory (C17) 检查给定的路径是否表示一个目录 (函数) is_empty (C17) 检查给定的路径是…
阅读更多...
STM32G474之使用DAC1和DAC2测试模拟比较器

STM32G474之使用DAC1和DAC2测试模拟比较器

STM32G474使用DAC1和DAC2的输出作为比较器输入&#xff0c;测试模拟比较器&#xff0c;方法如下&#xff1a; PA1的附加功能为COMP1_INP&#xff0c;无需映射&#xff0c;直接将它配置为模拟功能&#xff0c;就可以使用了。 将COMP1_OUT引脚映射到PA0; 采用DAC2_OUT1输出电压给…
阅读更多...
【大疆 SDR 图传 P1 】 功能拆解，通信功能剖析

【大疆 SDR 图传 P1 】 功能拆解，通信功能剖析

大疆 SDR 图传 P1 拆解视频P1 SoC1、哲酷2、小米3、大疆&#xff08;文章主角&#xff09; 一、为什么说SDR技术1、sdr 软件无线电2、影视博主的测评方法3、第一个说自己SDR的还是这个老登 二、大疆的图传发展历程1、FPGA AD93632、 P1 自研1、2个DSP和一个CPU A72、音频子系统…
阅读更多...
SpringMVC；MVC模式；Spring环境搭建；

SpringMVC；MVC模式；Spring环境搭建；

一&#xff0c;介绍MVC模式&#xff1a; MVC模式&#xff1a; 1.M:model 模型,业务模型和数据模型. 2.C:controller 控制器 3.V:view 视图 优点: 使用控制器C把视图V和业务模型M分离&#xff0c;从而使同一个程序可以使用不同的表现形式 使用场景: 中大型项目 核心: 控制器 二…
阅读更多...
828华为云征文 | 基于Docker与Jenkins实现自动化部署

828华为云征文 | 基于Docker与Jenkins实现自动化部署

需要了解 本文章主要讲述在 华为云Flexus X 实例上使用docker快速部署持续集成工具 Jenkins&#xff0c;通过插件来自动化CI/CD过程中的各种琐碎功能。选择合适的云服务器&#xff1a; 本文采用的是 华为云服务器 Flexus X 实例&#xff08;推荐使用&#xff09;连接方式&#…
阅读更多...
【自动驾驶】决策规划算法 | 数学基础（三）直角坐标与自然坐标转换Ⅰ

【自动驾驶】决策规划算法 | 数学基础（三）直角坐标与自然坐标转换Ⅰ

写在前面&#xff1a; &#x1f31f; 欢迎光临 清流君 的博客小天地&#xff0c;这里是我分享技术与心得的温馨角落。&#x1f4dd; 个人主页&#xff1a;清流君_CSDN博客&#xff0c;期待与您一同探索 移动机器人 领域的无限可能。 &#x1f50d; 本文系 清流君 原创之作&…
阅读更多...
【有啥问啥】数字孪生（Digital Twin）技术在人工智能中的应用

【有啥问啥】数字孪生（Digital Twin）技术在人工智能中的应用

数字孪生技术在人工智能中的应用 在当今的数字化转型过程中&#xff0c;“数字孪生”技术逐渐成为热门话题&#xff0c;并且在各个行业中展现出巨大的潜力。作为一种新兴技术&#xff0c;数字孪生&#xff08;Digital Twin&#xff09;不仅仅是物理对象的虚拟复制品&#xff0…
阅读更多...
MATLAB算法实战应用案例精讲-【人工智能】大数据审计（概念篇）

MATLAB算法实战应用案例精讲-【人工智能】大数据审计（概念篇）

目录 前言 大数据审计发展历程 1.初级阶段：验证型逻辑占据主导地位 2.发展阶段：挖掘型逻辑突出重围 3.成熟阶段：基于验证和挖掘的预测型逻辑发展 算法原理 什么是大数据审计 特征 事项审计 大数据审计的方法 (一)大数据审计的一般思路 (二)大数据审计的关键技术…
阅读更多...
【开发工具】探索IntelliJ IDEA插件——JSON Parser，让JSON处理变得轻松高效

【开发工具】探索IntelliJ IDEA插件——JSON Parser，让JSON处理变得轻松高效

开发过程中&#xff0c;遇到一个字符串&#xff0c;需要判断是否是JSON格式&#xff0c;或者是需要将Json字符串美化展示&#xff0c;是否还在打开百度搜JSON在线格式化(https://www.bejson.com/)&#xff0c;是否还在写个main方法将字符串转成JSON格式并输出。这篇文章&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023