【动态规划】MATLAB和Python实现-Part03

最新推荐文章于 2024-07-23 23:18:33 发布
最新推荐文章于 2024-07-23 23:18:33 发布
阅读量1.2k 收藏 2
点赞数 2
分类专栏： 数据结构&算法 MATLAB练习 MATLAB学习笔记 文章标签： 动态规划 matlab python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60090693/article/details/128270024
版权

动态规划系列文章~~~
🌹 发现有需要纠正的地方，烦请指正！
🚀 欢迎小伙伴们的三连+关注！

往期系列：
【动态规划】MATLAB和Python实现-Part01

【动态规划】MATLAB和Python实现-Part02

【动态规划】MATLAB和Python实现-Part03

零、回顾

在前两部分，我们由斐波那契数列开始，介绍了递归，又介绍了动态规划的两种思路：

  1. 带有备忘录的递归算法；
  2. 自底向上的算法

在该部分，我们将以几个例子来更加深入体会 动态规划。

一、礼物的最大价值

1.1 题目描述

在一个 m × n m\times n m×n （ m m m 和 n n n 都大于 1）的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

示例输入：

[1, 3, 1;
 1, 5, 1;
 4, 2, 1]

示例输出：
12
解释：
1+3+5+2+1=12 得到最多价值的礼物

1.2 题目分析

假设棋盘大小为 m × n m\times n m×n，第 i i i 行第 j j j 列格子中有价值为 M i j M_{ij} Mij​ 的礼物，如图：
在这里插入图片描述

因为我们要从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格，直到到达棋盘的右下角。
因此，棋盘中的某一个单元格只可能从它的上边一个单元格或左边一个单元格到达。

接下来我们按照这样的思路对题目进行分析：

  1. 定义原问题和子问题；
  2. 定义状态
  3. 寻找状态转移方程

定义原问题和子问题
原问题：
从棋盘的左上角开始，直到到达棋盘的右下角，计算能获得的最大礼物价值。
子问题：
从棋盘的左上角开始直到到达棋盘的第 i i i 行第 j j j 列 ( 1 ≤ i ≤ m , 1 ≤ j ≤ n ) (1\leq i \leq m,1 \leq j \leq n) (1≤i≤m,1≤j≤n)的格子所能获得的最大礼物价值。

定义状态
记 f ( i , , j ) f(i,,j) f(i,,j) 为从棋盘左上角走至第 i i i 行第 j j j 列的格子所能获得的最大礼物价值，这里可以认为 ( i , j ) (i,j) (i,j) 就是上述子问题的状态；
当 i = m , j = n i=m,j=n i=m,j=n 时，该状态对应的 f ( m , n ) f(m,n) f(m,n) 就是我们要求解的原问题的答案。

寻找状态转移方程
针对不同的条件，我们可以将其分为 4 种情况讨论：

  • 当 i = j = 1 i=j=1 i=j=1 时，这时候在起点，有： f ( 1 , 1 ) = M 11 f(1,1)=M_{11} f(1,1)=M11​
  • 当 i = 1 , j > 1 i=1,j>1 i=1,j>1 时，这时候在棋盘的第一行，说明此时的路线是从第一格一直向右走，则有： f ( 1 , j ) = f ( 1 , j − 1 ) + M 1 j f(1,j)=f(1,j-1)+M_{1j} f(1,j)=f(1,j−1)+M1j​
  • 当 i > 1 , j = 1 i>1,j=1 i>1,j=1 时，这时候在棋盘的第一列，说明此时的路线是从第一格一直向下走，则有： f ( i , 1 ) = f ( i − 1 , j ) + M i 1 f(i,1)=f(i-1,j)+M_{i1} f(i,1)=f(i−1,j)+Mi1​
  • 当 i , j > 1 i,j>1 i,j>1 时，此时可从上面或左面的格子到达，则需要选择较大价值的方案，则有： f ( i , j ) = m a x { f ( i , j − 1 ) , f ( i − 1 , j ) } + M i j f(i,j)=max\{f(i,j-1),f(i-1,j)\}+M_{ij} f(i,j)=max{f(i,j−1),f(i−1,j)}+Mij​

综上所述，得到最终的状态转移方程为：
f ( i , j ) = { M 11 i = j = 1 f ( 1 , j − 1 ) + M 1 j i = 1 , j > 1 f ( i − 1 , j ) + M i 1 i > 1 , j = 1 f ( i , j ) = m a x { f ( i , j − 1 ) , f ( i − 1 , j ) } + M i j i , j > 1 f(i,j)=\begin{cases} M_{11} & i=j=1\\ f(1,j-1)+M_{1j} & i=1,j>1\\ f(i-1,j)+M_{i1} & i>1,j=1\\ f(i,j)=max\{f(i,j-1),f(i-1,j)\}+M_{ij} & i,j>1 \end{cases} f(i,j)=⎩⎪⎪⎪⎨⎪⎪⎪⎧​M11​f(1,j−1)+M1j​f(i−1,j)+Mi1​f(i,j)=max{f(i,j−1),f(i−1,j)}+Mij​​i=j=1i=1,j>1i>1,j=1i,j>1​

1.3 编程求解

在对题目进行分析后，我们将使用 MATLAB 和 Python 实现编程求解：

MATLAB
函数实现：

function f = gift_value(M)
    [m,n] = size(M);
    dp = zeros(m,n);
    for i = 1:m
        for j = 1:n
            if i==1 & j==1
                dp(i,j) = M(i,j);
            elseif i==1 & j>1
                dp(i,j) = dp(i,j-1)+M(i,j);
            elseif i>1 & j==1
                dp(i,j) = dp(i-1,j)+M(i,j);
            else
                temp1 = dp(i,j-1)+M(i,j);
                temp2 = dp(i-1,j)+M(i,j);
                dp(i,j) = max(temp1,temp2);  
            end
        end
    end
    f = dp(m,n);
end

%% =====另一种思路=====
% function f = gift_value(M)
%     [m,n] = size(M);
%     dp = M;
%     dp(:,1) = cumsum(M(:,1));
%     dp(1,:) = cumsum(M(1,:));
%     for i = 2:m
%         for j = 2:n
%             temp1 = dp(i,j-1)+M(i,j);
%             temp2 = dp(i-1,j)+M(i,j);
%             dp(i,j) = max(temp1,temp2);
%         end
%     end
%     f = dp(m,n);
% end

函数调用：

clear;clc;
M = [2, 3, 5, 7;
     6, 5, 4, 5;
     7, 2, 3, 5;
     4, 6, 8, 1;
     6, 9, 4, 3];
tic;
gift_value(M)
toc;

结果：
在这里插入图片描述

Python
函数实现：

def gift_value(M):
    m, n = len(M), len(M[0])
    dp = [[-1 for j in range(n)] for i in range(m)]
    for i in range(m):
        for j in range(n):
            if i==0 and j==0:
                dp[i][j] = M[i][j]
            elif i==0 and j>0:
                dp[i][j] = dp[i][j-1]+M[i][j]
            elif i>0 and j==0:
                dp[i][j] = dp[i-1][j]+M[i][j]
            else:
                temp1 = dp[i][j-1]
                temp2 = dp[i-1][j]
                dp[i][j] = max(temp1, temp2)+M[i][j]
    return dp[-1][-1]

函数调用：

import time
M = [[2, 3, 5, 7], [6, 5, 4, 5], [7, 2, 3, 5], [4, 6, 8, 1], [6, 9, 4, 3]]
start = time.time()
f = gift_value(M)
print('礼物的最大价值动态规划算法得到的结果为：')
print(f)
end = time.time()
print()
print('礼物的最大价值动态规划算法用时(s)：')
print('%.8f' % (end-start))

结果：
在这里插入图片描述

1.4 算法深入：得到所走的路线

在得到最大的礼物价值后，想要进一步得到所走的路线，应该如何做？

注意：产生最大礼物价值的路线可能不唯一，我们只需要输出其中一种路线即可。

我们这里从DP数组的最后一个元素出发（将DP数组的元素也对应放在棋盘中），逆着推出整个路线：
因为正常的路线每次只能选择 向下或者向右，所以逆路线只能选择 向上或者向左；
而我们判断的思路就是，比较所处位置 上格子
中的值和 左格子 中的值，选取较大的一个，不断重复直到左上角，这就是最终的路线。

具体代码实现如下：
MATLAB
函数实现：

function [f,path] = gift_value_path(M)
    [m,n] = size(M);
    dp = zeros(m,n);
    for i = 1:m
        for j = 1:n
            if i==1 & j==1
                dp(i,j) = M(i,j);
            elseif i==1 & j>1
                dp(i,j) = dp(i,j-1)+M(i,j);
            elseif i>1 & j==1
                dp(i,j) = dp(i-1,j)+M(i,j);
            else
                temp1 = dp(i,j-1)+M(i,j);
                temp2 = dp(i-1,j)+M(i,j);
                dp(i,j) = max(temp1,temp2);  
            end
        end
    end
    f = dp(m,n);
    path = zeros(m,n);
    i=m;j=n;
    while i~=1 || j~=1
        path(i,j) = 1;
        if i == 1
            path(1,1:j) = 1;
            break;
        end
        if j == 1
            path(1:i,1) = 1;
            break;
        end
        temp1 = dp(i-1,j);
        temp2 = dp(i,j-1);
        if temp1>=temp2
            i = i-1;
        else
            j = j-1;
        end
    end
end

函数调用：

clear;clc;
M = [2, 3, 5, 7;
     6, 5, 4, 5;
     7, 2, 3, 5;
     4, 6, 8, 1;
     6, 9, 4, 3];
tic;
[f,path] = gift_value_path(M)
toc;

结果：
其中 path 矩阵中，为 1 则表示路径中存在这个格子，为 0 则表示不存在。
在这里插入图片描述

这里我们再给出另一种实现方式：
比上述方法复杂一丢丢，与上述方法不同之处，已在注释中标注。

function [f,path] = gift_value_path(M)
    [m,n] = size(M);
    dp = zeros(m,n);
    for i = 1:m
        for j = 1:n
            if i==1 & j==1
                dp(i,j) = M(i,j);
            elseif i==1 & j>1
                dp(i,j) = dp(i,j-1)+M(i,j);
            elseif i>1 & j==1
                dp(i,j) = dp(i-1,j)+M(i,j);
            else
                temp1 = dp(i,j-1)+M(i,j);
                temp2 = dp(i-1,j)+M(i,j);
                dp(i,j) = max(temp1,temp2);  
            end
        end
    end
    f = dp(m,n);
    % 推出路径path
    path = zeros(m,n);
    i = m;
    j = n;
    while i ~= 1 || j ~= 1
        path(i,j) = 1;
        if i == 1
            path(1,1:j) = 1;
            break;
        end
        if j == 1
            path(1:i,1) = 1;
           break;
        end
        temp1 = dp(i-1,j);
        temp2 = dp(i,j-1);
        %% 接下来稍有不同
        ind = find([temp1,temp2]==(dp(i,j)-M(i,j)),1);
        if ind==1
            i = i-1;
        else
            j = j-1;
        end
    end
end

Python
函数实现：

def gift_value_path(M):
    m, n = len(M), len(M[0])
    dp = [[-1 for j in range(n)] for i in range(m)]
    for i in range(m):
        for j in range(n):
            if i==0 and j==0:
                dp[i][j] = M[i][j]
            elif i==0 and j>0:
                dp[i][j] = dp[i][j-1]+M[i][j]
            elif i>0 and j==0:
                dp[i][j] = dp[i-1][j]+M[i][j]
            else:
                temp1 = dp[i][j-1]
                temp2 = dp[i-1][j]
                dp[i][j] = max(temp1, temp2)+M[i][j]

    path = [[0 for j in range(n)] for i in range(m)]
    i = m-1
    j = n-1
    while i!=0 or j!=0:
        path[i][j] = 1
        if i==0:
            for k in range(j):
                path[0][k] = 1
            break
        if j==0:
            for k in range(i):
                path[k][0] = 1
            break
        temp1 = dp[i-1][j]
        temp2 = dp[i][j-1]
        if temp1>=temp2:
            i = i-1
        else:
            j = j-1
    return dp[-1][-1], path

函数调用：

import time
M = [[2, 3, 5, 7], [6, 5, 4, 5], [7, 2, 3, 5], [4, 6, 8, 1], [6, 9, 4, 3]]
start = time.time()
f, path = gift_value_path(M)
print('礼物的最大价值动态规划算法得到的结果为：')
print(f)
print('对应的路线为：')
print(path)
end = time.time()
print()
print('礼物的最大价值动态规划算法用时(s)：')
print('%.8f' % (end-start))

结果：
在这里插入图片描述

二、零钱兑换

2.1 题目描述

给定不同面值的硬币 coins 和一个总金额 S。编写一个函数来计算可以凑成总金额所需的 最少 的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。
示例输入：
coins=[1,2,5],S=11
示例输出：
3
解释：
11=5+5+1 共需三枚硬币。

2.2 题目分析

定义原问题和子问题
原问题：
可以凑成总金额 S S S 所需的最少硬币个数。
子问题：
可以凑成金额 x ( x ≤ S ) x(x\leq S) x(x≤S) 所需的最少硬币个数。

定义状态
我们记 f ( x ) f(x) f(x) 为凑成目标金额 x x x 所需的最少硬币个数，这里的目标金额 x x x 就表示子问题所对应的状态。

寻找状态转移方程
这个问题的状态转移方程不容易寻找，我们可以从下面一个具体的例子入手：

假设 coins=[1, 2, 5, 20], S=11，我们现在要求 f ( 11 ) f(11) f(11)，那么可以知道：状态10，状态9和状态6 可以经过 1 步转移到 状态11，所以我们可以推出： f ( 11 ) = m i n { f ( 10 , f ( 9 ) , f ( 6 ) } + 1 f(11)=min\{f(10,f(9),f(6)\}+1 f(11)=min{f(10,f(9),f(6)}+1.

在此基础上，我们考虑其一般情形，若有 c o i n s = [ c 1 , c 2 , . . . , c m ] coins=[c_{1},c_{2},...,c_{m}] coins=[c1​,c2​,...,cm​]，目标金额为 x x x，那么有： f ( x ) = m i n { f ( x − c 1 ) , f ( x − c 2 ) , . . . , f ( x − c m ) } + 1 f(x)=min\{f(x-c_{1}),f(x-c_{2}),...,f(x-c_{m})\}+1 f(x)=min{f(x−c1​),f(x−c2​),...,f(x−cm​)}+1
但是要注意两种情况：

  • 若 x − c i < 0 x-c_{i}<0 x−ci​<0，说明这个硬币的面值已经超过我们的目标金额，我们就令 f ( x − c i ) = + ∞ f(x-c_{i})=+\infty f(x−ci​)=+∞，这样在取最小值后就排除了这种可能；
  • 若 x − c i = 0 x-c_{i}=0 x−ci​=0，说明这个硬币的面值刚好等于我们的目标金额，有 f ( x − c i ) = 0 f(x-c_{i})=0 f(x−ci​)=0 。

2.3 编程求解

在对题目进行分析后，我们将使用 MATLAB 和 Python 实现编程求解：

MATLAB
函数实现：

function f = coin_change(coins,S)
    dp = +inf*ones(1,S+2);
    dp(S+2) = 0;
    % dp数组中第S+1和S+2项不改变
    % 第S+1项始终为 正无穷
    % 第S+2项始终为 0
    for x = 1:S
        ind = x-coins;      % 计算前一步的状态
        ind(ind<0) = S+1;   % 状态小于0，令其为 正无穷对应的下标
        ind(ind==0) = S+2;  % 状态等于0，令其为 零对应的下标
        dp(x) = min(dp(ind))+1;
    end
    if dp(S)<+inf
        f = dp(S);
    else
        f = -1;
    end
end

函数调用：

clear;clc;
coins = [1, 3, 5, 6, 7];
S = 41;
tic;
f = coin_change(coins, S)
toc;

结果：
在这里插入图片描述

Python
函数实现：

def coin_change(coins, S):
    MAX = 99999999
    dp = [MAX for i in range(S+2)]
    dp[S+1] = 0
    for x in range(1, S+1):
        lis = []
        for j in coins:
            temp = x-j      # 计算前一步状态
            ind = temp-1    # ind是在dp中的索引，因此要用temp减去1
            if temp<0:
                ind = S     # 状态小于0，令其为 正无穷对应的索引
            elif temp==0:
                ind = S+1   # 状态等于0，令其为 零对应的索引
            lis.append(dp[ind])
        dp[x-1] = min(lis)+1

    if dp[S-1]<MAX:
        return dp[S-1]
    else:
        return -1

coins = [1, 3, 5, 6, 7]
S = 41
print(coin_change(coins, S))

函数调用：

import time
coins = [1, 3, 5, 6, 7]
S = 41
start = time.time()
print('最终需要的硬币数为：')
print(coin_change(coins, S))
end = time.time()
print('算法用时为(s)：')
print('%.8f' % (end-start))

结果：
在这里插入图片描述

2.4 算法深入：得到具体的硬币组合

我们已经知道了前面的测试结果为：6，即最少需要 6 枚硬币来达到我们的目标金额。
那我们如何知道这 6 枚硬币是怎么组成的呢？

  • 首先我们知道，这 6 枚硬币的总金额为 41，且有 coins=[1, 3, 5, 6, 7]；
  • 那么可以知道，如果有 5 枚硬币，可能的组成金额分别是：41-1=40，41-3=38，41-5=36，41-6=35，41-7=34；
  • 接下来，验证上述 5 枚硬币总金额：40, 38, 36, 35, 34 的存在性，即在 DP数组 中查找相应位置，判断是否为 5，若判断为真，我们就确定了一枚硬币 （比如，DP数组中位置 34 对应的值为 5，那么我们就可确定一枚面值为 7 的硬币）；
  • 按照上述步骤，不断重复过程，直至找到所有硬币。

根据上述分析，我们分别用 MATLAB 和 Python 实现代码如下：
MATLAB
函数实现：

function [f,PART] = coin_change_part(coins,S)
    dp = +inf*ones(1,S+2);
    dp(S+2) = 0;
    for x = 1:S
        ind = x-coins;      % 计算前一步的状态
        ind(ind<0) = S+1;   % 状态小于0，令其为正无穷
        ind(ind==0) = S+2;  % 状态等于0，令其为零
        dp(x) = min(dp(ind))+1;
    end
    if dp(S)<+inf
        f = dp(S);
        p = S;		% p先指向最后一个位置
        PART = [];	% 初始化硬币组合向量
        while dp(p)>1
            q = p;	% 预保存前一个位置
            ind = p-coins;
            ind(ind<0) = S+1;
            ind(ind==0) = S+2;
            p = ind(find(dp(ind)==(dp(p)-1),1));
            PART = [PART, q-p];
        end
        PART = [PART,p];
    else
        f = -1;
    end
end

函数调用：

clear;clc;
coins = [1, 3, 5, 6, 7];
S = 41;
tic;
[f,PART] = coin_change_part(coins, S)
toc;

结果：
在这里插入图片描述

Python
函数实现：

def coin_change(coins, S):
    MAX = 99999999
    dp = [MAX for i in range(S+2)]
    dp[S+1] = 0
    for x in range(1, S+1):
        lis = []
        for j in coins:
            temp = x-j      # 计算前一步状态
            ind = temp-1    # ind是在dp中的索引，因此要用temp减去1
            if temp<0:
                ind = S     # 状态小于0，令其为 正无穷对应的索引
            elif temp==0:
                ind = S+1   # 状态等于0，令其为 零对应的索引
            lis.append(dp[ind])
        dp[x-1] = min(lis)+1

    if dp[S-1]<MAX:
        p = S-1
        PART = []
        while dp[p]>1:
            q = p   # 预保存前一个位置
            ind_lis = []
            for j in coins:
                temp = p - j  # 计算前一步状态
                ind = temp - 1  # ind是在dp中的索引，因此要用temp减去1
                if temp < 0:
                    ind = S  # 状态小于0，令其为 正无穷对应的索引
                elif temp == 0:
                    ind = S + 1  # 状态等于0，令其为 零对应的索引
                ind_lis.append(ind)
            for k in range(len(ind_lis)):
                if dp[ind_lis[k]]==(dp[p]-1):
                    p = ind_lis[k]
            PART.append(q-p)
        PART.append(p+1)    # 将索引+1，得到对应金额
        return dp[S-1], PART
    else:
        return -1, []

函数调用：

import time
coins = [1, 3, 5, 6, 7]
S = 41
start = time.time()
print('最终需要的硬币数为：')
f, PART = coin_change(coins, S)
print(f)
print('硬币组合为：')
print(PART)
end = time.time()
print('算法用时为(s)：')
print('%.8f' % (end-start))

结果：
在这里插入图片描述

四口鲸鱼爱吃盐
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python中zeros函数和ones函数的详细用法
Python热爱者的博客
06-07 2971
在使用Python进行数据分析和科学计算时，经常需要创建和操作多维数组。NumPy是Python中一个常见的数学库，它提供了许多方便的函数来创建、操作和处理多维数组。NumPy中常用的两个函数是zeros()函数和ones()函数。这些函数可以帮助我们快速创建特定维度和形状的多维数组，并设置初始值。下面是这两个函数的详细用法。
【动态规划】MATLAB和Python实现-Part04
四口鲸鱼爱吃盐的博客
12-12 1320
【动态规划】MATLAB和Python实现-Part04 零、回顾 一、0-1背包问题 1.1 题目描述；1.2 题目分析；1.3 题目求解；1.4 得到选择物品的编号 二、硬币兑换的方案；2.1 题目描述；2.2 题目分析；2.3 题目求解
MATLAB 使用python代码
Chengliangyao的博客
12-24 9283
matlab是一个非常强大的数学处理工具，python中很多工具库封装得非常好，对于高版本的MATLAB来说，可以直接使用python以及这些库，我这里使用的R2017a版本，网上说2015版开始就可以，没有测试，步骤如下： 1、将python添加至matlab里面 2、使用python 使用时以 py.xxx来使用，比如使用list 使用库一样，比如我这里要使用sklearn计算NM...
【动态规划】MATLAB和Python实现-Part01
四口鲸鱼爱吃盐的博客
12-09 1701
动态规划系列文章~~~ 🌹 发现有需要纠正的地方，烦请指正！ 🚀 欢迎小伙伴们的三连+关注！ 【动态规划】MATLAB和Python实现-Part01 一、斐波那契数列；二、递归；2.1 以阶乘计算为例；2.2 以斐波那契数列计算为例；2.3 对递归的反思与改进；2.3.1 带有备忘录的递归算法；2.3.2 自底向上法
离散控制Matlab代码-Cabot-Part-1:设计和实现自动驾驶汽车系统
05-23
自动驾驶汽车系统的设计和实现–第1部分 什么是自动驾驶汽车系统？ 基于Wikipedia的无人驾驶车辆是一种无需人工输入即可感知其环境并进行导航的车辆。 通过使用雷达，激光雷达，GPS，里程计和计算机视觉等传感器，...
matlab跑c代码-ObjectDetectionModel:目标检测中一些重要特征提取算法的Python实现
05-27
一些目标检测领域经典检测器的轮子，主要帮助自己理解一些重要的目标检测特征提取算法的原理与实现，基于python3.6+pytorch1.7.1， 使用Tensorboard进行训练过程的可视化 Histograms of Oriented Gradients 数据集...
MATLAB C/C++, Fortran, Java, and Python API Reference
08-18
《MATLAB C/C++, Fortran, Java, and Python API 参考手册》是MATLAB公司发布的一份技术文档，旨在为使用C/C++, Fortran, Java和Python编程语言与MATLAB进行接口开发的用户提供详细指南。该参考手册覆盖了如何在这些...
matlab集成c代码-Natural-Language-Processing-Part-I-Primer:自然语言处理部分I引物
05-22
计算和矩阵处理是在Matlab中完成的（Python确实具有类似Matlab的库numpy，但由于偏好我们使用了Matlab）。 步骤1：下载Python集成开发环境（IDE）。 出于说明目的，我们使用了Anaconda。 第2步：获取情感词列表，并...
matlab代码close-Price-data-of-part-of-US-Stocks-in-2014-2019:2014-2019年美国
05-26
Price-data-of-part-of-US-Stocks-in-2014-2019 价格数据通过python库yfinance取自雅虎财经，股票筛选池(eastmoney.csv，共12561支)为东方财富的美股列表() The price data are downloaded through a python library...
43.简易DDS信号发生器的设计与验证（2）
2301_80417284的博客
07-19 483
简易DDS信号发生器的设计与验证（2） key_ctrl模块的设计与验证、rom的设计
Matlab得到无背景透明图片
不勤劳搬运工的博客
07-22 119
注意：本方法是复制得到透明图片，不是保存得到透明图 ！！！
最小二乘求待定位点的位置（三维环境）|MATLAB
callmeup的博客
07-19 336
这里给出三维情况下的函数和测试代码。对于函数，输入已知锚点的位置、待测点与各个锚点的距离，即可获得待测点的坐标。可自定义锚点坐标、待测点坐标、测距误差。
matlab y = 1/√x图像和y = 1/x图像
zhanghanqmx的博客
07-19 245
【代码】matlab y = 1/√x图像和y = 1/x图像。
应用最优化方法及MATLAB实现——第5章代码实现
GFCLJY的博客
07-18 677
继上一章代码后，这篇主要是针对于第5章代码的实现。部分代码有更改，会在下面说明，程序运行结果跟书中不完全一样，因为部分参数，书中并没有给出其在运行时设置的值，所以我根据我自己的调试进行了设置，运行出来的结果跟书中的结果大致一致。
matlab仿真 模拟调制（下）
qq_55999494的博客
07-23 116
（内容源自详解MATLAB／SIMULINK 通信系统建模与仿真 刘学勇编著第五章内容，有兴趣的读者请阅读原书）求调频指数的公式为：kf*Amax/fm，其中的Amax是振幅的最大值，这里可以理解为消息序列的最大绝对值。（1）：在求FM信号相位的过程中。
数字图像处理中的常用特殊矩阵及MATLAB应用
最新发布
xrgs_shz的博客
07-23 689
一、前言Matlab的名称来源于“矩阵实验室（Matrix Laboratory）”，其对矩阵的操作具有先天性的优势（特别是相对于C语言的数组来说）。在数字图像处理中，为了提高编程效率，我们可以使用多种方式来创建特殊的矩阵或图像处理矩阵，如全零矩阵、全1矩阵、单位矩阵、顺序矩阵、稀疏矩阵、随机矩阵等。二、特殊矩阵的生成及应用元素全为零的矩阵称为全零矩阵，MATLAB可以使用zeros创建全零矩阵。
88个群智能算法优化BP神经网络 多特征输入单输出回归预测Matlab程序
2401_86241083的博客
07-19 794
在Matlab中优化神经网络的初始权重涉及选择合适的算法和方法来调整网络的权重，以优化模型的预测能力和性能。具体来说，如果有88种智能算法可供选择，那么每种算法都有其独特的优势和适用场景。
MATLAB练习题——矩阵（2）
T3ARWIPE的博客
07-23 148
（1）组合成一个 4*3 的矩阵，第一列为按列顺序排列的 a 矩阵元素，第二列为按列顺序排列的 b 矩阵 元素，第三列为按列顺序排列的 c 矩阵元素。a = [5 0.2 0 -8 -0.7 ]，在进行逻辑运算时，a 相当于什么样的逻辑量。角度 x=[ 30 45 60 ]，求 x 的正弦、余弦、正切和余切。（2）按照 a、b、c 的列顺序组合成一个行矢量。在 sin(x)运算中，x 是角度还是弧度？或利用（1）中产生的 d。在 sin(x)运算中，x 是。，MATLAB 规定。
Matlab画不同指标的对比图
332295505的博客
07-22 167
深度学习指标结果图绘制，包括F1,Acc,Sp,Se,Pr等。数据可自行输入（一维列表的长度需要与评价指标个数相等）。各个模型名字可修改。
Python数据挖掘实战指南
与传统的MATLAB®相比，Python以其易学性和丰富的库（如Pandas、NumPy和SciPy）在数据分析领域占据了一席之地。 书中内容涵盖了Python的基础语法和数据结构，如何使用pandas库进行数据加载、处理和分析，如数据清洗...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

四口鲸鱼爱吃盐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值