【算法篇】动态规划类（1）（笔记）

news2024/10/25 21:19:39

目录

一、理论基础

1. 大纲

2. 动态规划的解题步骤

二、LeetCode 题目

1. 斐波那契数

2. 爬楼梯

3. 使用最小花费爬楼梯

4. 不同路径

5. 不同路径 II

6. 整数拆分

7. 不同的二叉搜索树

一、理论基础

1. 大纲

        动态规划，英文：Dynamic Programming，简称 DP，如果 某一问题有很 多重叠子问题，使用动态规划 是最有效的。

        动态规划中 dp[j] 是由 dp[j-weight[i]] 推导出来的，然后取 max(dp[j], dp[j - weight[i]] + value[i])。 

2. 动态规划的解题步骤

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

二、LeetCode 题目

1. 斐波那契数

https://leetcode.cn/problems/fibonacci-number/submissions/569810951/icon-default.png?t=O83Ahttps://leetcode.cn/problems/fibonacci-number/submissions/569810951/

        斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0，F(1) = 1 F(n) = F(n - 1) + F(n - 2)，其中 n > 1 给你n ，请计算 F(n) 。

示例 1：
输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：
输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：
输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

理解：

    ① dp[i] 的定义为：第 i 个数的 斐波那契数值是 dp[i]。

    ② 状态转移方程 dp[i] = dp[i - 1] + dp[i - 2]。

    ③ 初始化。

dp[0] = 0;
dp[1] = 1;

// 写法一：
class Solution {
public:
    int fib(int n) {
        if (n < 2) return n;
        return fib(n - 1) + fib(n - 2);
    }
};


// 写法二：
class Solution {
public:
    int fib(int n) {
        int f0 = 0, f1 = 1;
        int num;
        if (n == 1) return f1;
        if (n == 0) return f0;
        for (int i = 1; i < n; i++) {
            num = f0 + f1;
            f0 = f1;
            f1 = num;
        }
        return num;
    }
};

2. 爬楼梯

https://leetcode.cn/problems/climbing-stairs/description/icon-default.png?t=O83Ahttps://leetcode.cn/problems/climbing-stairs/description/

        假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：
输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：
输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

理解：

   ① dp[i]： 爬到第i层楼梯，有dp[i]种方法。

   ② dp[i] = dp[i - 1] + dp[i - 2] ：首先是 dp[i - 1]，上 i-1 层楼梯，有 dp[i - 1] 种方法，那么再一步跳一个台阶不就是 dp[i] 了。还有就是 dp[i - 2]，上 i-2 层楼梯，有 dp[i - 2] 种方法，那么再一步跳两个台阶不就是 dp[i] 了。

   ③ dp[0] = 1，相当于直接站在楼顶。

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) return n;
        int dp[2] = {1, 2};
        for (int i = 2; i < n; i++) {
            int num = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = num;
        }
        return dp[1];
    }
};

3. 使用最小花费爬楼梯

https://leetcode.cn/problems/min-cost-climbing-stairs/description/icon-default.png?t=O83Ahttps://leetcode.cn/problems/min-cost-climbing-stairs/description/

        给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

        你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

        请你计算并返回达到楼梯顶部的最低花费。

示例 1：
输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：
输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

理解：

   ① 到达第 i 台阶所花费的最少体力为 dp[i]。

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

        可以有 两个途径得到 dp[i]，一个是dp[i-1] 一个是 dp[i-2]。

        dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。

        dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。

   ③ dp[0] = 0，dp[1] = 0;

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

4. 不同路径

https://leetcode.cn/problems/unique-paths/description/icon-default.png?t=O83Ahttps://leetcode.cn/problems/unique-paths/description/

        一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

        机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

        问总共有多少条不同的路径？

示例 1：
输入：m = 3, n = 7
输出：28

示例 2：
输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：
输入：m = 7, n = 3
输出：28

示例 4：
输入：m = 3, n = 3
输出：6

理解：

   ① dp[i][j] ：表示从（0 ，0）出发，到 (i, j) 有 dp[i][j] 条不同的路径。

   ② dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为 dp[i][j] 只有这两个方向过来。

   ③ dp[i][0] 一定都是 1，因为从 (0, 0) 的位置到 (i, 0) 的路径只有一条，那么 dp[0][j] 也同理。

// 方法一：（二维数组实现）
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m; i++) dp[i][0] = 1;
        for (int j = 0; j < n; j++) dp[0][j] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};


// 方法二：（一维数组实现）
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<int> dp(n);
        for (int i = 0; i < n; i++) dp[i] = 1;
        for (int j = 1; j < m; j++) {
            for (int i = 1; i < n; i++) {
                dp[i] += dp[i - 1];
            }
        }
        return dp[n - 1];
    }
};


// 方法三：
class Solution {
public:
    int uniquePaths(int m, int n) {
        if (m == 0 || n == 0) return 1;
        vector<vector<int>> buff(m, vector<int>(n, 0));
        buff[0][0] = 1;
        for (int row = 0; row < m; row++) {
            for (int col = 0; col < n; col++) {
                 if (row == 0 && col == 0) continue;
                 else if (row == 0) buff[0][col] = buff[0][col - 1];
                 else if (row > 0 && col == 0) buff[row][0] = buff[row - 1][0];
                 else buff[row][col] = buff[row - 1][col] + buff[row][col - 1];
                //  cout << buff[row][col] << " ";
            }
            // cout << endl;
        }
        return buff[m - 1][n - 1];
    }
};

5. 不同路径 II

https://leetcode.cn/problems/unique-paths-ii/description/icon-default.png?t=O83Ahttps://leetcode.cn/problems/unique-paths-ii/description/

        给定一个 m x n 的整数数组 grid。一个机器人初始位于 左上角（即 grid[0][0]）。机器人尝试移动到 右下角（即 grid[m - 1][n - 1]）。机器人每次只能向下或者向右移动一步。

        网格中的障碍物和空位置分别用 1 和 0 来表示。机器人的移动路径中不能包含 任何 有障碍物的方格。

        返回机器人能够到达右下角的不同路径数量。

        测试用例保证答案小于等于 2 * 109。

示例 1：
输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
  1. 向右 -> 向右 -> 向下 -> 向下
  2. 向下 -> 向下 -> 向右 -> 向右

示例 2：
输入：obstacleGrid = [[0,1],[0,0]]
输出：1

理解：

   ① dp[i][j] ：表示从（0 ，0）出发，到 (i, j) 有 dp[i][j] 条不同的路径。

   ② 从 (0, 0) 的位置到 (i, 0) 的路径只有一条，所以 dp[i][0] 一定为 1，dp[0][j] 也同理。但如果 (i, 0) 这条边有了障碍之后，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的 dp[i][0] 应该还是 初始值 0。

// 方法一：（二维数组保存）
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        // 二维数组保存
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) return 0;
        vector<vector<int>> buff(m, vector<int>(n, 0));
        buff[0][0] = 1;
        for (int row = 0; row < m; row++) {
            for (int col = 0; col < n; col++) {
                if ((row == 0 && col == 0) || obstacleGrid[row][col] == 1) continue;
                else if (row == 0) buff[row][col] = buff[row][col - 1];
                else if (col == 0) buff[row][0] = buff[row - 1][0];
                else buff[row][col] = buff[row - 1][col] + buff[row][col - 1];
            }
        }
        return buff[m - 1][n - 1];
    }
};


// 方法二：（一维数组保存）
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};


// 方法三：
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        // 二维数组保存
        if (obstacleGrid[0][0] == 1) return 0;
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        vector<vector<int>> buff(m, vector<int>(n, 0));
        buff[0][0] = 1;
        for (int row = 0; row < m; row++) {
            for (int col = 0; col < n; col++) {
                if ((row == 0 && col == 0) || obstacleGrid[row][col] == 1) continue;
                else if (row == 0) buff[row][col] = buff[row][col - 1];
                else if (col == 0) buff[row][0] = buff[row - 1][0];
                else buff[row][col] = buff[row - 1][col] + buff[row][col - 1];
            }
        }
        return buff[m - 1][n - 1];
    }
};

6. 整数拆分

https://leetcode.cn/problems/integer-break/description/icon-default.png?t=O83Ahttps://leetcode.cn/problems/integer-break/description/

        给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。返回 你可以获得的最大乘积 。

示例 1:
输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:
输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

理解：

   ①dp[i]：分拆数字 i，可以得到的 最大乘积为 dp[i]。

   ②有两种渠道得到 dp[i]：一个是 j * (i - j) 直接相乘。一个是 j * dp[i - j]，相当于是拆分 (i - j)。j 是从 1 开始遍历，拆分 j 的情况，在遍历 j 的过程中其实都计算过了。那么从 1 遍历 j，比较 (i - j) * j 和 dp[i - j] * j 取最大的。递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

   ③这里只初始化 dp[2] = 1，从 dp[i] 的定义来说，拆分数字 2，得到的最大乘积是 1。

class Solution {
public:
    int integerBreak(int n) {
        // dp 表示 对应为下标数字时 拆分的最大值，可以由之前下标数组最大值得出
        vector<int> dp(n + 1, 0);
        dp[2] = 1;  // 数字代表拆分的数字
        for (int i = 3; i <= n; i++) {
            for (int j = 1; j <= i / 2; j++) {
                // 从 1 开始拆，有拆和不拆两种选择
                dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
            }
        }
        return dp[n];
    }
};

7. 不同的二叉搜索树

https://leetcode.cn/problems/unique-binary-search-trees/description/icon-default.png?t=O83Ahttps://leetcode.cn/problems/unique-binary-search-trees/description/

        给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

示例 1：
输入：n = 3
输出：5

示例 2：
输入：n = 1
输出：1

理解：

   ① dp[i] ： 1 到 i 为节点组成的二叉搜索树的个数为 dp[i]。

   ② dp[i] += dp[j - 1] * dp[i - j]; ，j - 1 为 j 为头结点左子树节点数量，i - j 为以 j 为头结点右子树节点数量。

   ③ dp[以 j 为头结点左子树节点数量] * dp[以 j 为头结点右子树节点数量] 中以 j 为头结点左子树节点数量为 0，也需要 dp[以 j 为头结点左子树节点数量] = 1， 否则乘法的结果就都变成 0 了。所以初始化 dp[0] = 1。

class Solution {
public:
    int numTrees(int n) {
        if (n == 1) return 1;
        vector<int> dp(n + 1, 0);
        dp[0] = 1, dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                dp[i] += dp[j] * dp[i - j - 1];
            }
        }
        return dp[n];
    }
};

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

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

相关文章

企业水、电、气、热等能耗数据采集系统

企业水、电、气、热等能耗数据采集系统

介绍 通过物联网技术&#xff0c;采集企业水、电、气、热等能耗数据&#xff0c;帮企业建立能源管理体系&#xff0c;找到跑冒滴漏&#xff0c;从而为企业节能提供依据。 进一步为企业实现碳跟踪、碳盘查、碳交易、谈汇报的全生命过程。 为中国碳达峰-碳中和做出贡献。 针对客…
阅读更多...
【C++进阶】set的使用

【C++进阶】set的使用

1. 序列式容器和关联式容器 前面&#xff0c;我们已经接触过STL中的部分容器如&#xff1a;string、vector、list、deque、array、forward_list等&#xff0c;这些容器统称为序列式容器&#xff0c;因为逻辑结构为线性序列的数据结构&#xff0c;两个位置存储的值之间⼀般没有紧…
阅读更多...
【工具箱】Flash基础及“SD NAND Flash”的测试例程

【工具箱】Flash基础及“SD NAND Flash”的测试例程

目录 一、“FLASH闪存”是什么&#xff1f; 1. 简介 2. 分类 3. 性能 4.可靠性 5.易用性 二、SD NAND Flash 1. 概述 2. 特点 3. 引脚分配 4. 数据传输模式 5. SD NAND寄存器 6. 通电图 7. 参考设计 三、STM32测试例程 1. 初始化 2. 单数据块测试 3. 多数据块…
阅读更多...
场景题 - 画三角形并只点击三角形触发事件

场景题 - 画三角形并只点击三角形触发事件

简介 画一个三角形并仅点击三角形区域才会触发点击事件。 可以拆解成&#xff1a; 画个三角形绑定点击事件&#xff08;涉及点击区域&#xff09; 这里提供更多更好用的方法&#xff0c;svg polygon绘制三角形、canvas、css clip-path:polygon( ) 裁剪可视区域&#xff0c;并…
阅读更多...
文件和目录的权限管理

文件和目录的权限管理

定义&#xff1a; 文件和目录的权限管理在操作系统中至关重要&#xff0c;特别是在多用户环境下&#xff0c;它决定了不同用户对文件和目录的访问和操作权限。 一、基本权限类型及表示方法 在Linux系统中&#xff0c;文件和目录的权限分为三类&#xff1a;读取权限&#xff08;…
阅读更多...
谷歌-BERT-第一步：模型下载

谷歌-BERT-第一步：模型下载

1 需求 需求1&#xff1a;基于transformers库实现自动从Hugging Face下载模型 需求2&#xff1a;基于huggingface-hub库实现自动从Hugging Face下载模型 需求3&#xff1a;手动从Hugging Face下载模型 2 接口 3.1 需求1 示例一&#xff1a;下载到默认目录 from transform…
阅读更多...
南邮-软件安全--第一次实验报告-非爆破计算校验值

南邮-软件安全--第一次实验报告-非爆破计算校验值

软件安全第一次实验报告&#xff0c;切勿直接搬运&#xff08;改改再交&#xff09; 实验要求 1、逆向分析目标程序运行过程&#xff0c;找到程序的关键校验点&#xff1b; 2、以非爆破的方式正确计算crackme的校验值&#xff1b; 内容 使用x32dbg对文件进行分析 打开文件…
阅读更多...
思迈特：在AI时代韧性增长的流量密码

思迈特：在AI时代韧性增长的流量密码

作者 | 曾响铃 文 | 响铃说 “超级人工智能将在‘几千天内’降临。” 最近&#xff0c;OpenAI 公司 CEO 山姆奥特曼在社交媒体罕见发表长文&#xff0c;预言了这一点。之前&#xff0c;很多专家预测超级人工智能将在五年内到来&#xff0c;奥特曼的预期&#xff0c;可能让这…
阅读更多...
构建可扩展的高校学科竞赛平台：SpringBoot案例分析

构建可扩展的高校学科竞赛平台：SpringBoot案例分析

2相关技术 2.1 MYSQL数据库 MySQL是一个真正的多用户、多线程SQL数据库服务器。 是基于SQL的客户/服务器模式的关系数据库管理系统&#xff0c;它的有点有有功能强大、使用简单、管理方便、安全可靠性高、运行速度快、多线程、跨平台性、完全网络化、稳定性等&#xff0c;非常…
阅读更多...
高效管理学科竞赛：SpringBoot平台的创新应用

高效管理学科竞赛：SpringBoot平台的创新应用

1系统概述 1.1 研究背景 随着计算机技术的发展以及计算机网络的逐渐普及&#xff0c;互联网成为人们查找信息的重要场所&#xff0c;二十一世纪是信息的时代&#xff0c;所以信息的管理显得特别重要。因此&#xff0c;使用计算机来管理高校学科竞赛平台的相关信息成为必然。开发…
阅读更多...
Zookeeper快速入门：部署服务、基本概念与操作

Zookeeper快速入门：部署服务、基本概念与操作

文章目录 一、部署服务1.下载与安装2.查看并修改配置文件3.启动 二、基本概念与操作1.节点类型特性总结使用场景示例查看节点查看节点数据 2.文件系统层次结构3.watcher 一、部署服务 1.下载与安装 下载&#xff1a; 一定要下载编译后的文件&#xff0c;后缀为bin.tar.gz w…
阅读更多...
算法：525.连续数组

算法：525.连续数组

题目 链接&#xff1a;leetcode 思路分析&#xff08;前缀和&#xff09; 首先介绍一个小技巧 在处理二进制数组的时候&#xff0c;因为数组里面只有0和1&#xff0c;我们可以将所有的0变成-1 这个时候1和-1之间就可以产生很多抵消&#xff0c;有利于处理数组。 在该题中&am…
阅读更多...
2.2.1 绘制Canvas路径 - 绘制线条

2.2.1 绘制Canvas路径 - 绘制线条

文章目录 1. 绘制线条2. 绘制具有不同结束线帽的线条3. 绘制向阳花图形 今天我们要一起探讨的是如何使用HTML5的Canvas元素来绘制各种图形。Canvas提供了一个强大的图形绘制API&#xff0c;使我们能够在网页上绘制出各种复杂的图形和动画。接下来&#xff0c;我将通过几个实战示…
阅读更多...
从Naive RAG到Agentic RAG：基于Milvus构建Agentic RAG

从Naive RAG到Agentic RAG：基于Milvus构建Agentic RAG

检索增强生成&#xff08;Retrieval-Augmented Generation, RAG&#xff09;作为应用大模型落地的方案之一&#xff0c;通过让 LLM 获取上下文最新数据来解决 LLM 的局限性。典型的应用案例是基于公司特定的文档和知识库开发的聊天机器人&#xff0c;为公司内部人员快速检索内部…
阅读更多...
如何在数仓中处理缓慢变化维度（SCD）

如何在数仓中处理缓慢变化维度（SCD）

在数据仓库中&#xff0c;处理缓慢变化维度&#xff08;SCD&#xff0c;Slowly Changing Dimension&#xff09;是一个非常常见且重要的问题。为了保证数据的完整性和准确性&#xff0c;我们通常会采取不同的策略来处理维度表中的数据变化。SCD的核心解决方案是通过不同类型的历…
阅读更多...
Run the FPGA VI 选项的作用

Run the FPGA VI 选项的作用

Run the FPGA VI 选项的作用是决定当主机 VI 运行时&#xff0c;FPGA VI 是否会自动运行。 具体作用&#xff1a; 勾选 “Run the FPGA VI”&#xff1a; 当主机 VI 执行时&#xff0c;如果 FPGA VI 没有正在运行&#xff0c;系统将自动启动并运行该 FPGA VI。 这可以确保 FPG…
阅读更多...
使用Hugging Face中的BERT进行标题分类

使用Hugging Face中的BERT进行标题分类

使用Hugging Face中的BERT进行标题分类 前言相关介绍出处基本原理优点缺点 前提条件实验环境BERT进行标题分类准备数据集读取数据集划分数据集设置相关参数创建自己DataSet对象计算准确率定义预训练模型定义优化器训练模型保存模型测试模型 参考文献 前言 由于本人水平有限&…
阅读更多...
视频文案提取

视频文案提取

视频文案提取 通义听悟 &#x1f3c6;优点 自动提取音视频关键词、总结、提炼视频大纲、中英双字幕可以识别不同声音进行文案区分&#xff0c;还支持直接AI改写提取的文案旁边还有AI助手帮助你回答问题和对知识举一反三相关视频介绍&#x1f449;原地封神&#xff01;录音、…
阅读更多...
拆解学习【反激-PD-氮化镓】（一）

拆解学习【反激-PD-氮化镓】（一）

小米67W桌面快充插座&#xff1a; 反激基本拓扑&#xff1a; 商用场景下&#xff0c;这个拓扑进行了如下优化&#xff1a; 1.Q22换成了氮化镓开关管&#xff0c;当然需要适配的能驱动氮化镓的控制芯片 2.D21二极管换成了MOS管。 3.由于是AC220V输入&#xff0c;设计了整流桥…
阅读更多...
在Centos中安装、配置与使用atop监控工具

在Centos中安装、配置与使用atop监控工具

目录 前言1. atop工具的安装1.1 atop简介1.2 atop的安装步骤 2. 安装并配置netatop模块2.1 安装内核开发包2.2 安装所需依赖2.3 下载netatop2.4 解压并安装netatop2.5 启动netatop 3. atop的配置与使用3.1 配置监控周期与日志保留时间3.2 设置定时任务生成日志3.3 启动与查看at…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023