动态规划----股票买卖问题（详解）

目录

一.买卖股票的最佳时机：

二.买卖股票的最佳时机含冷冻期：

三.买卖股票的最佳时期含⼿续费：

四.买卖股票的最佳时机III: 

五.买卖股票的最佳时机IV:

买卖股票的最佳时机问题介绍：动态规划买卖股票的最佳时机是一个经典的算法问题。该问题的目标是在给定的股票价格数组中，找到最大的利润，即最佳的买入和卖出时间，使得买入时间早于卖出时间。

下面我们通过一些例题，来解决这一类动态规划的问题：

一.买卖股票的最佳时机：

  • 题目链接：121. 买卖股票的最佳时机 - 力扣（LeetCode）
  • 题目描述：

    给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

    你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

    返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

①.动态规划解法：

  • 一.状态表示dp[ i ][ j ]：下标为 i 这一天结束的时候，手上持股状态为 j 时，我们持有的最大利润。这里我们定义状态 j （两种情况）分别为：
  • 0 买入状态
  • 1 可交易状态
  • 二.状态转移方程：
  • dp[ i ][ 0 ] = Math.max( dp[ i - 1 ][ 0 ], -prices[ i ]) ; ①.在前面一天已经是买入状态，今天选择什么也不干，今天结束后，是买入状态。②.前面是可交易状态，今天选择买入，则今天结束后是买入状态，这里注意不是dp[ i - 1][ 1 ] - prices[ i ];因为只能交易一次，如果今天选择买入，那后面一定要卖出（这算一次交易),此时才可能有最大利润。则前面不能有交易，利润为0.
  • dp[ i ][ 1 ] = Math.max( dp[ i - 1][ 1 ],dp[ i - 1][ 0 ] + prices[ i ]);①.前面一天是可交易状态，今天选择什么也不干，今天结束后是可交易状态。②.前面一天是买入状态，今天选择卖出，今天结束后是可交易状态。
  • 三.初始化：根据状态表示：
  • dp[ 0 ][ 0 ] = - prices[ 0 ];第一天选择买入，此时利润为 - prices[ 0 ]
  • dp[ 0 ][ 1 ] = 0;第一天选择什么也不干或则交易一次，此时的利润为0;
  • 四.填表顺序：根据状态转移方程，从左往右，从上往下填写.
  • 五.返回值：dp[ n - 1 ][ 1 ];n为prices数组的长度,最后一天结束后，是可交易状态，此时为最大利润.

各个状态关系图：

代码详解：

class Solution {
         // 1. 创建 dp 表
        // 2. 初始化
       // 3. 填表
       // 4. 返回值
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        //初始化
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        for(int i = 1;i < n;i++){
            //注意这里不是dp[i - 1][1] - prices[i];
            dp[i][0] = Math.max(dp[i - 1][0], - prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1],dp[i - 1][0] + prices[i]);
        }
        //返回值
        return dp[n - 1][1];
    }
}

②.暴力解法（相对简单这里给出解题过程）： 

代码详解：

class Solution {
    public int maxProfit(int[] prices) {
        int cost = Integer.MAX_VALUE;
        int profit = 0;
        for(int price : prices){
            cost = Math.min(cost,price);
            profit = Math.max(profit,price - cost);
        }
        return profit;
    }
}

运行结果：

 

二.买卖股票的最佳时机含冷冻期：

  • 题目链接：309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）
  • 问题描述：

    给定一个整数数组prices，其中第  prices[i] 表示第 i 天的股票价格 。​

    设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

  • 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

  • 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

动态规划解法：

一.状态表示：dp[ i ][ j ]:由于有「买⼊」「可交易」「冷冻期」三个状态，因此我们可以选择⽤三个数组，其中：

  • dp[i][0] 表⽰：第 i 天结束后，处于「买⼊」状态，此时的最⼤利润；
  • dp[i][1] 表⽰：第 i 天结束后，处于「可交易」状态，此时的最⼤利润；
  • dp[i][2] 表⽰：第 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][2]); ①.前面一天是可交易状态，今天啥也不干，今天结束后是可交易状态②.前面一天是冷冻期，今天啥也不干，今天过后是可交易状态
  • dp[i][2] = dp[i - 1][0] + prices[i]；前面一天是买入状态，今天选择卖出，今天过后是冷冻期

三.初始化：

dp[0][0] = - prices[0] ；   dp[0][1] = 0 ；    dp[0][2] = 0;

四.填表顺序：从左往右，从上往下，依次填写三个表

五.返回值：状态转移方程三者的最大值：

 max(dp[n - 1][1], dp[n - 1] [2]);dp[n - 1][0]不可能是最大值，这里不用考虑进去（如果考虑进去了也没关系）

各个状态关系图：

代码详解：

class Solution {
      // 1. 创建 dp 表
        // 2. 初始化
       // 3. 填表
       // 4. 返回值
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][3];
        dp[0][0] = -prices[0];
        for(int i = 1;i < n;i++){
            dp[i][0] = Math.max(dp[i - 1][0],dp[i - 1][1] - prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1],dp[i - 1][2]);
            dp[i][2] = dp[i - 1][0] + prices[i];
        }
        return Math.max(dp[n - 1][1],dp[n - 1][2]);
    }
}

运行结果： 

三.买卖股票的最佳时期含⼿续费：

题目链接：714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）

题目描述：

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

 动态规划解法：

一.状态表示：由于有「买⼊」「可交易」两个状态，因此我们可以选择⽤两个数组来定义我们的状态（或则一个二维数组也行），其中：

  • f[i] 表⽰：第 i 天结束后，处于「买⼊」状态，此时的最⼤利润；
  • g[i] 表⽰：第 i 天结束后，处于「卖出」状态，此时的最⼤利润.

二.状态转移方程 ：我们选择在「卖出」的时候，⽀付这个⼿续费，那么在「买⼊」的时候，就不⽤再考虑⼿续费的问题（完成一次交易支付手续费）：

  • f[i] = max(f[i - 1], g[i - 1] - prices[i]) ；①.在 i - 1 天「持有」股票，第 i 天啥也不⼲。此时最⼤收益为 f[i - 1] ；②.在 i - 1 天的时候「没有」股票，在第 i 天买⼊股票。此时最⼤收益为 g[i - 1] - prices[i]) ；
  • g[i] = max(g[i - 1], f[i - 1] + prices[i] - fee);①.在 i - 1 天「持有」股票，但是在第 i 天将股票卖出。此时最⼤收益为： f[i - 1] + prices[i] - fee) ，记得⼿续费；②.在 i - 1 天「没有」股票，然后第 i 天啥也不⼲。此时最⼤收益为： g[i - 1]

三.初始化：由于需要⽤到前⾯的状态，因此需要初始化第⼀个位置:

  • 对于 f[0] ，此时处于「买⼊」状态，因此 f[0] = -prices[0]
  • 对于 g[0] ，此时处于「没有股票」状态，啥也不⼲即可获得最⼤收益，因此 g[0] = 0 

四.填表顺序：从左到右两个表一起填

五.返回值：应该返回「卖出」状态下，最后⼀天的最⼤值收益： g[n - 1] 

代码详解：

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int n = prices.length;
        int[] f = new int[n];
        int[] g = new int[n];
        f[0] = -prices[0];
        for(int i = 1;i < n;i++){
            f[i] = Math.max(f[i - 1],g[i - 1] - prices[i]);
            g[i] = Math.max(g[i - 1],f[i - 1] + prices[i] - fee);
        }
        return Math.max(f[n - 1],g[n - 1]);
    }
}

运行结果：

四.买卖股票的最佳时机III: 

题目链接：123. 买卖股票的最佳时机 III - 力扣（LeetCode）

题目描述：

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

动态规划解法：

一.状态表示：由于有「买⼊」「可交易」两个状态，因此我们可以选择⽤两个数组。但是这道题⾥⾯还有交易次 数的限制，因此我们还需要再加上⼀维，⽤来表⽰交易次数。其中：

  • f[i][j] 表⽰：第 i 天结束后，完成了 j 次交易，处于「买⼊」状态，此时的最⼤利 润；
  • g[i][j] 表⽰：第 i 天结束后，完成了 j 次交易，处于「卖出」状态，此时的最⼤利 润。

二.状态转移方程：

  • f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);①.在 i - 1 天的时候，交易了 j 次，处于「买⼊」状态，第 i 天啥也不⼲即可。此时最 ⼤利润为： f[i - 1][j] ；②.在 i - 1 天的时候，交易了 j 次，处于「卖出」状态，第 i 天的时候把股票买了。此 时的最⼤利润为： g[i - 1][j] - prices[i] 。
  • g[i][j] = g[i - 1][j];

      if(j > 0) g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);  

     ①.在 i - 1 天的时候，交易了 j 次，处于「卖出」状态，第 i 天啥也不⼲即可。此时的 最             ⼤利润为： g[i - 1][j] ；

    ②.在 i - 1 天的时候，交易了 j - 1 次，处于「买⼊」状态，第 i 天把股票卖了，然 后就完          成了 j ⽐交易。此时的最⼤利润为： f[i - 1][j - 1] + prices[i] 。但 是这个状态不⼀定存              在，要先判断⼀下。

三.初始化：

  • 当处于第 0 天的时候，只能处于「买⼊过⼀次」的状态，此时的收益为 -prices[0] ，因 此 f[0][0] = - prices[0] 。
  • 为了取 max 的时候，⼀些不存在的状态「起不到⼲扰」的作⽤，我们统统将它们初始化为 - INF （⽤ INT_MIN 在计算过程中会有「溢出」的⻛险，这⾥ INF 折半取 0x3f3f3f3f ，⾜够⼩即可）

四.填表顺序：从「上往下填」每⼀⾏，每⼀⾏「从左往右」，两个表「⼀起填」。

五.返回值：返回处于「卖出状态」的最⼤值，但是我们也「不知道是交易了⼏次」，因此返回 g 表最后⼀⾏ 的最⼤值。

代码详解：

class Solution {
    static int INF = -0x3f3f3f3f;
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] f = new int[n][3];
        int[][] g = new int[n][3];
        //1.
        f[0][0] = -prices[0];
        for(int i = 1;i < f[0].length;i++){
            f[0][i] = INF;
        }
        for(int j = 1;j < g[0].length;j++){
            g[0][j] = INF;//Integer.MIN_VALUE/2
        }
        
        //2.
        for(int i = 1;i < n;i++){
            for(int j = 0;j < 3;j++){
                f[i][j] = Math.max(f[i - 1][j],g[i - 1][j] - prices[i]);
                g[i][j] = g[i - 1][j];
                if(j > 0){
                    g[i][j] = Math.max(g[i][j],f[i - 1][j - 1] + prices[i]);
                }
            }
        }
        int res = Integer.MIN_VALUE;
        for(int j = 0;j < 3;j++){ 
           res = Math.max(res,g[n - 1][j]);
        }
        return res;
    }
}

运行结果：

五.买卖股票的最佳时机IV:

题目链接：188. 买卖股票的最佳时机 IV - 力扣（LeetCode）

题目描述：

给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

动态规划解法：

一.状态表示：为了更加清晰的区分「买⼊」和「卖出」，我们换成「有股票」和「⽆股票」两个状态：

  • f[i][j] 表⽰：第 i 天结束后，完成了 j 笔交易，此时处于「有股票」状态的最⼤收益；
  • g[i][j] 表⽰：第 i 天结束后，完成了 j 笔交易，此时处于「⽆股票」状态的最⼤收益

二.状态转移方程：

  • f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);①.在 i - 1 天的时候，⼿⾥「有股票」，并且交易了 j 次。在第 i 天的时候，啥也不⼲。 此时的收益为 f[i - 1][j] ；②.在 i - 1 天的时候，⼿⾥「没有股票」，并且交易了 j 次。在第 i 天的时候，买了股 票。那么 i 天结束之后，我们就有股票了。此时的收益为 g[i - 1][j] - prices[i];
  • g[i][j] = max(g[i - 1][j], f[i - 1][j - 1] + prices[i]);①.在 i - 1 天的时候，⼿⾥「没有股票」，并且交易了 j 次。在第 i 天的时候，啥也不 ⼲。此时的收益为 g[i - 1][j] ；②.在 i - 1 天的时候，⼿⾥「有股票」，并且交易了 j - 1 次。在第 i 天的时候，把 股票卖了。那么 i 天结束之后，我们就交易了 j 次。此时的收益为 f[i - 1][j - 1] + prices[i] ；

三.初始化：

  • 当处于第 0 天的时候，只能处于「买⼊过⼀次」的状态，此时的收益为 -prices[0] ，因 此 f[0][0] = - prices[0]
  • 为了取 max 的时候，⼀些不存在的状态「起不到⼲扰」的作⽤，我们统统将它们初始化为 - INF （⽤ INT_MIN 在计算过程中会有「溢出」的⻛险，这⾥ INF 折半取 0x3f3f3f3f ，⾜够⼩即可）

四.填表顺序：从上往下填每⼀⾏，每⼀⾏从左往右，两个表⼀起填。

五.返回值：返回处于卖出状态的最⼤值，但是我们也不知道是交易了⼏次，因此返回 g 表最后⼀⾏的最⼤ 值

代码详解：

class Solution {
    static int INF = -0x3f3f3f3f;
    public int maxProfit(int k, int[] prices) {
        int n = prices.length;
        int[][] f = new int[n][k + 1];
        int[][] g = new int[n][k + 1];
        //1.
        f[0][0] = -prices[0];
        for(int i = 1;i < f[0].length;i++){
            f[0][i] = INF;//->防止越界g[i - 1][j] - prices[i];
        }
        for(int j = 1;j < g[0].length;j++){
            g[0][j] = INF;//Integer.MIN_VALUE/2
        }
        
        //2.
        for(int i = 1;i < n;i++){
            for(int j = 0;j < k + 1;j++){
                f[i][j] = Math.max(f[i - 1][j],g[i - 1][j] - prices[i]);
                g[i][j] = g[i - 1][j];
                if(j > 0){
                    g[i][j] = Math.max(g[i][j],f[i - 1][j - 1] + prices[i]);
                }
            }
        }
        int res = Integer.MIN_VALUE;
        for(int j = 0;j < k + 1;j++){ 
           res = Math.max(res,g[n - 1][j]);
        }
        return res;
    }
}

运行结果：

 结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！

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

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

相关文章

排序2——冒泡排序，快速排序（3种递归方式+3种非递归方式）

排序2——冒泡排序，快速排序（3种递归方式+3种非递归方式）

目录 1.交换排序 2.冒泡排序 2.1基本思路 1.1.2复杂度分析 3.快速排序 3.1基本思想 3.2Hoare版本&#xff08;最初的&#xff09; 3.2.1缺点 3.2.2优化 第一种——随机选key 第二种——三数取中 第三种——小区间优化 3.3挖坑版本&#xff08;更好理解&#xff09…
阅读更多...
【谷粒商城】01-环境准备

【谷粒商城】01-环境准备

1.下载和安装VirtualBox 地址&#xff1a;https://www.virtualbox.org/wiki/Downloads 傻瓜式安装VirtualBox 2.下载和安装Vagrant官方镜像 地址&#xff1a;https://app.vagrantup.com/boxes/search 傻瓜式安装 验证是否安装成功 打开CMD,输入vagrant命令&#xff0c;是否…
阅读更多...
pyqt5将ui文件转为python文件

pyqt5将ui文件转为python文件

在pyqt5中使用 pyuic将ui文件转为py文件&#xff1a; 例如&#xff1a;将home.ui文件转为vio_detect.py文件&#xff0c;所需命令如下&#xff1a; pyuic5 -x home.ui -o vio_detect.py
阅读更多...
【Linux】基于 Jenkins+shell 实现更新服务所需文件 --＞两种方式：ssh/Ansible

【Linux】基于 Jenkins+shell 实现更新服务所需文件 --＞两种方式：ssh/Ansible

&#x1f468;‍&#x1f393;博主简介 &#x1f3c5;云计算领域优质创作者   &#x1f3c5;华为云开发者社区专家博主   &#x1f3c5;阿里云开发者社区专家博主 &#x1f48a;交流社区&#xff1a;运维交流社区 欢迎大家的加入&#xff01; &#x1f40b; 希望大家多多支…
阅读更多...
STL-Hashtable

STL-Hashtable

hashtable hashtable是通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系&#xff0c;这样在查找的时候就可以很快的找到该元素。 哈希函数 哈希函数的定义域必须包括需要存储的全部关键码&#xff0c;而如果散列表允许有m个地址时&#xff0c…
阅读更多...
C++内存管理（1）

C++内存管理（1）

目录 1.new用法说明 2.new/delete在栈里面的运用 3.operator new/operator delete函数 4.构造函数的显式调用 5.malloc&&new&&free&&delete区别 1.new用法说明 &#xff08;1&#xff09;在C语言阶段&#xff0c;我们无论是为数组开辟空间&#x…
阅读更多...
瀚高数据库（HighGoDB）Windows安装使用

瀚高数据库（HighGoDB）Windows安装使用

1.下载 2.安装 瀚高数据库下载与安装&#xff08;Windows版&#xff09;-CSDN博客 3.连接工具 4.建库、建表操作 瀚高数据库管理工具-CSDN博客 *报错Cant access non-default database&#xff0c;需要右键数据库-设为活动对象 5.导入外部数据&#xff08;迁移、对比&…
阅读更多...
云贝教育 |【好课上新】ITSS服务工程师与服务经理认证培训

云贝教育 |【好课上新】ITSS服务工程师与服务经理认证培训

课程前言 ITSS是中国电子技术标准化研究院推出的&#xff0c;包含“IT 服务工程师”和“IT 服务经理”的系列培训。有效满足GB/T 28827.1 的符合性评估要求和ITSS服务资质升级要求。 IT 服务工程师”结合 IT服务从业人员能力规范和要求&#xff0c;从服务技术、服务技巧和服务…
阅读更多...
Linux环境下parted工具使用

Linux环境下parted工具使用

在工作中&#xff0c;我们经常会遇到大于分区大于2T的磁盘&#xff0c;由于系统盘最大不能超2T&#xff0c;我们会在做raid时将划分VD来进行装系统&#xff0c;但系统自动安装后无法将磁盘全部识别出来&#xff0c;管理员有时会要求手动对分区进行挂载&#xff0c;这个文档介绍…
阅读更多...
基于PSO粒子群优化的PV光伏发电系统simulink建模与仿真

基于PSO粒子群优化的PV光伏发电系统simulink建模与仿真

目录 1.课题概述 2.系统仿真结果 3.核心程序与模型 4.系统原理简介 4.1 粒子群优化算法基础 4.2 PV系统及其最大功率点跟踪 4.3 PSO在PV MPPT中的应用 5.完整工程文件 1.课题概述 基于PSO粒子群优化的PV光伏发电系统simulink建模与仿真。通过PSO粒子群优化进行最大功率…
阅读更多...
Day25 代码随想录打卡|栈与队列篇---用队列实现栈

Day25 代码随想录打卡|栈与队列篇---用队列实现栈

题目&#xff08;leecode T225&#xff09;&#xff1a; 请你仅使用两个队列实现一个后入先出&#xff08;LIFO&#xff09;的栈&#xff0c;并支持普通栈的全部四种操作&#xff08;push、top、pop 和 empty&#xff09;。 实现 MyStack 类&#xff1a; void push(int x) 将…
阅读更多...
每日OJ题_贪心算法四④_力扣397. 整数替换

每日OJ题_贪心算法四④_力扣397. 整数替换

目录 力扣397. 整数替换 解析代码 力扣397. 整数替换 397. 整数替换 难度 中等 给定一个正整数 n &#xff0c;你可以做如下操作&#xff1a; 如果 n 是偶数&#xff0c;则用 n / 2替换 n 。如果 n 是奇数&#xff0c;则可以用 n 1或n - 1替换 n 。 返回 n 变为 1 所需…
阅读更多...
C# Linq中的自定义排序

C# Linq中的自定义排序

1.开发过程中&#xff0c;会遇到OrderBy/OrderByDescending排序无法满足的情况&#xff0c;此时就需要自定义排序&#xff0c;按照想要的排序规则取排序&#xff0c;比如订单的状态等等。 2.自定义泛型比较器代码如下&#xff1a; /// <summary>/// 自定义泛型比较器(用…
阅读更多...
【ArcGIS 小技巧脚本工具】批量修复CAD图层的数据源

【ArcGIS 小技巧脚本工具】批量修复CAD图层的数据源

当你打开ArcPro文档的时候&#xff0c;看到内容列表满屏红色感叹号。 新手可能会心脏骤停&#xff0c;久经沙场的规划人只会微微一笑。随机选中一个幸运的红色感叹号点击&#xff0c;打开更改数据源对话框&#xff0c;找到它原始的数据源&#xff0c;确定。 but。。。为啥只修复…
阅读更多...
将CentOS 7安装在U盘上，这时你将体验到......

将CentOS 7安装在U盘上，这时你将体验到......

文章目录 前言一、Linux 是什么&#xff1f;二、使用步骤1.下载安装 VMware Workstation Pro2.下载 CentOS 镜像3.准备一个U盘&#xff08;最好是32G以上的&#xff09;4.VMware 里安装 CentOS 总结 前言 随着 Linux 在服务器、嵌入式系统、移动设备等领域的广泛应用&#xff…
阅读更多...
【通义千问系列】Qwen-Agent 从入门到精通【持续更新中……】

【通义千问系列】Qwen-Agent 从入门到精通【持续更新中……】

目录 前言一、快速开始1-1、介绍1-2、安装1-3、开发你自己的Agent 二、Qwen-Agent的使用和开发过程2-1、Agent2-1-1、Agent使用2-1-2、Agent开发 2-2、Tool2-2-1、工具使用2-2-2、工具开发 2-3、LLM2-3-1、LLM使用2-3-2、LLM开发 三、基于Qwen-Agent的案例分析3-1、3-2、 总结 …
阅读更多...
Linux i2c工具——i2c_tools

Linux i2c工具——i2c_tools

1 简介 i2c-tools是一个用于处理I2C&#xff08;Inter-Integrated Circuit&#xff09;总线的工具集&#xff0c;它在Linux环境中广泛使用。这个工具集包含了一系列命令行工具&#xff0c;用于在I2C总线上执行各种操作&#xff0c;例如扫描设备、读取/写入寄存器、检测设备等。…
阅读更多...
【jitsi】jitsi 布署及docker打包

【jitsi】jitsi 布署及docker打包

目录 单独的布署 最后总结的成果 旧的架构 单独的布署 最后总结的成果 http://10.30.40.10/dualvenDoc/installjitsi/ 旧的架构 wvp视频调度平台架构布署图_wvp 架构-CSDN博客
阅读更多...
插入法（直接/二分/希尔）

插入法（直接/二分/希尔）

//稳定耗时&#xff1a; 双向冒泡&#xff0c;可指定最大最小值个数MaxMinNum<nsizeof(Arr)/sizeof(Arr[0]), void BiBubbleSort(int Arr[],int n&#xff0c;int MaxMinNum){int left0,rightn-1;int i;bool notDone true;int temp;int minPos;while(left<right&&am…
阅读更多...
【WEEK11】 【DAY6】员工管理系统第七部分【中文版】

【WEEK11】 【DAY6】员工管理系统第七部分【中文版】

2024.5.11 Saturday 接上文【WEEK11】 【DAY5】员工管理系统第六部分【中文版】 目录 10.8.删除及404处理10.8.1.修改list.html10.8.2.修改EmployeeController.java10.8.3.重启10.8.4. 404页面处理10.8.4.1.把404.html文件移入10.8.4.2.重启并运行 10.8.5.退出登录状态10.8.5.1…
阅读更多...
最新文章

Copyright @ 2022~2023