【算法与数据结构】回溯算法、贪心算法、动态规划、图论(笔记三)

文章目录

  • 七、回溯算法
  • 八、贪心算法
  • 九、动态规划
    • 9.1 背包问题
    • 9.2 01背包
    • 9.3 完全背包
    • 9.4 多重背包
  • 十、图论
    • 10.1 深度优先搜索
    • 10.2 广度优先搜索
    • 10.3 并查集

  最近博主学习了算法与数据结构的一些视频,在这个文章做一些笔记和心得,本篇文章就写了一些基础算法和数据结构的知识点,具体题目解析会放在另外一篇文章。在学习时已经有C, C++的基础。文章附上了学习的代码,仅供大家参考。如果有问题,有错误欢迎大家留言。算法与数据结构一共有三篇文章,剩余文章可以在 【CSDN文章】晚安66博客文章索引找到。

七、回溯算法

  回溯算法也可以叫回溯搜索法,它是一种搜索的方式。回溯是递归的副产品,有递归就有回溯,因此回溯函数就是递归函数。回溯法的本质是穷举,穷举所有可能,然后选出我们想要的答案。如果想要令回溯法更加高效一些,那就加一些剪枝操作。虽然说回溯法并不高效,但是一些问题不得不用回溯法,能用暴力搜索解出来就不错了,在剪枝,除此之外没有更高效的解法。回溯法用来及诶觉以下的几个问题:

  • 组合问题:N个数里面按一定规则找出k个数的集合
  • 切割问题:一个字符串按一定规则有几种切割方式
  • 子集问题:一个N个数的集合里有多少符合条件的子集
  • 排列问题:N个数按一定规则全排列,有几种排列方式
  • 棋盘问题:N皇后,解数独等等

  回溯法解决的问题可以抽象为树形结构,因为回溯法解决的问题都是在集合中递归查找子集,集合的大小就构成了树的宽度,递归的深度,都构成树的深度。递归就要有终止条件,所以必然是一颗高度有限的树。回溯算法的伪代码:

void backtracking(参数) {if (终止条件) {存放结果;return;}for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {处理节点;backtracking(路径,选择列表); // 递归回溯,撤销处理结果}
}

八、贪心算法

  贪心算法的本质是选择每一阶段的局部最优,从而达到全局最优。贪心算法经典问题有:背包问题,买卖股票的最佳时机。贪心算法没有固定的套路,说白了就是常识性推导加上举反例。贪心算法一般分为以下四个步骤:

  • 1、将问题分解为若干个子问题
  • 2、找出合适的贪心策略
  • 3、求解每一个子问题的最优解
  • 4、将局部最优解堆叠成全局最优解

九、动态规划

  动态规划(Dynamic Programming, DP),如果一个问题有很多重叠的子问题,使用动态规划是最有效的。所有动态规划总每一个状态由上一个状态推导出来,这一点就区别于贪心算法,贪心算法没有状态变量的推导,而是从局部直接选最优的。动态规划问题可以分为下面五个步骤:

  • 1、确定dp数组(dp table)以及下标的含义
  • 2、确定递推公式
  • 3、dp数组如何初始化
  • 4、确定遍历顺序
  • 5、举例推导dp数组
      在很多动态规划题目当中,确定了递推公式,题目就自然的解出来了。同时,在debug动态规划题目是,将dp数组打印出来,观察其变化是否按照自己所预想的那样。

9.1 背包问题

  对于背包问题来说,主要可以分为两个部分:背包和物品。背包的最大容量为 V V V,物品具有价值 W W W,体积 v v v以及每个物品的数量。如果根据物品数量进行分类,可以分为01背包问题,完全背包问题,多重背包问题和分组背包问题

  • 01背包:每种物品的数量只有一个;
  • 完全背包:物品数量有无数个;
  • 多重背包:不同物品的数量可以不同;
  • 分组背包:按组打包,每组最多选一个。
      对于找工作面试来说,掌握01背包,完全背包和多重背包就够了。LeetCode的题库中没有纯01背包问题,需要转化成01背包问题。

9.2 01背包

  有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。每件物品只能用一次,求解将哪些物品装入背包里物品价值总和最大。题目假设如下,背包最大重量为4。

在这里插入图片描述

  根据动态规划的五个步骤,我们首先确认dp数组的含义。假设一个二维 d p [ i ] [ j ] dp[i][j] dp[i][j]数组代表了从下标为 [ 0 − i ] [0-i] [0i]的物品里任意取,放进容量为 j j j的背包,最大价值总和。第二步确认递归公式。不放物品:当第 i i i个物品不放进去时,此时的价值和前面的相同,有 d p [ i ] [ j ] = d p [ i − 1 ] [ j ] dp[i][j] = dp[i - 1][j] dp[i][j]=dp[i1][j]放物品:放物品的前提是放入的物品重量不大于背包现有容量,当然这个可以用 i f if if语句控制。假设能放进去,那么放进去之后的价值 d p [ i ] [ j ] dp[i][j] dp[i][j],可以表示为 d p [ i − 1 ] [ j − w e i g h t [ i ] ] + v a l u e [ i ] dp[i - 1][j - weight[i]] + value[i] dp[i1][jweight[i]]+value[i]。其中, d p [ i − 1 ] [ j − w e i g h t [ i ] ] dp[i - 1][j-weight[i]] dp[i1][jweight[i]]为背包容量为 j − w e i g h t [ i ] j - weight[i] jweight[i]的时候不放物品i的最大价值, v a l u e [ i ] value[i] value[i]为物品 i i i的价值。综合以上分析,我们可以得到递归公式: d p [ i ] [ j ] = m a x ( d p [ i − 1 ] [ j ] , d p [ i − 1 ] [ j − w e i g h t [ i ] ] + v a l u e [ i ] ) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]) dp[i][j]=max(dp[i1][j],dp[i1][jweight[i]]+value[i])

  第三步我们进行初始化,因为 i i i是由 i − 1 i-1 i1初始化而来的,那么我们将 d p [ i ] [ 0 ] dp[i][0] dp[i][0]初始化为0。实际上我们在构建dp数组的时候可以将二维数组中的所有元素初始化为0,而非零的值将在循环遍历中被覆盖。然后初始化第一行当 j > w e i g h t [ i ] j>weight[i] j>weight[i]时(背包可以放假物品0), d p [ 0 ] [ j ] dp[0][j] dp[0][j]应该是 v a l u e [ 0 ] value[0] value[0]。第四步,确定遍历顺序。遍历的两个维度分别是物品和背包重量,遍历物品相对比遍历背包重量更容易理解:

在这里插入图片描述

  

// 初始化 dp
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++) {dp[0][j] = value[0];
}
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品for(int j = 0; j <= bagweight; j++) { // 遍历背包容量if (j < weight[i]) dp[i][j] = dp[i - 1][j];else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);}
}

  当然,上述的dp数组也可以写成一维滚动数组形式。下面的代码舍去了初始化的代码,舍去下标二维dp数组的下标 i i i从而变成了一维数组。主要原因是 d p [ i − 1 ] [ j ] dp[i - 1][j] dp[i1][j]完全可以用 d p [ j ] dp[j] dp[j]来表示。二维dp遍历的时候,背包容量是从小到大,而一维dp遍历的时候,背包是从大到小。倒序遍历是为了保证物品i只被放入一次!。但如果一旦正序遍历了,那么物品0就会被重复加入多次!

  举一个例子:物品0的重量weight[0] = 1,价值value[0] = 15。如果正序遍历dp[1] = dp[1 - weight[0]] + value[0] = 15,dp[2] = dp[2 - weight[0]] + value[0] = 30。此时dp[2]就已经是30了,意味着物品0,被放入了两次,所以不能正序遍历。

  倒序就是先算dp[2]。dp[2] = dp[2 - weight[0]] + value[0] = 15 (dp数组已经都初始化为0),dp[1] = dp[1 - weight[0]] + value[0] = 15。所以从后往前循环,每次取得状态不会和之前取得状态重合,这样每种物品就只取一次了。

class Solution {	// 一维dp数组(滚动数组形式)
public:int bag01(const vector<int> weight, const vector<int> value, const int bagweight) {vector<int> dp(vector<int>(bagweight + 1, 0));for (int i = 0; i < weight.size(); i++) {			// 遍历物品for (int j = bagweight; j >= weight[i]; j--) {			// 遍历背包容量dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);}}return dp[bagweight];}
};

  简言之,一维dp数组和二维dp数组的区别在于一维的空间复杂度低,二维的更容易理解(初学者用二维即可)。以上的完整代码如下:

# include <iostream>
# include <vector>
using namespace std;class Solution {
public:int bag01(const vector<int> weight, const vector<int> value, const int bagweight) {vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));for (int j = weight[0]; j <= bagweight; j++) {		// 初始化dp[0][j] = value[0];}for (int i = 1; i < weight.size(); i++) {			// 遍历物品for (int j = 0; j <= bagweight; j++) {			// 遍历背包容量if (j < weight[i]) dp[i][j] = dp[i - 1][j];else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);}}return dp[weight.size() - 1][bagweight];}
};int main() {Solution s1;vector<int> weight = { 1, 3, 4 };vector<int> value = { 15, 20, 30 };int bagweight = 4;int result = s1.bag01(weight, value, bagweight);cout << result << endl;system("pause");return 0;
}

9.3 完全背包

  完全背包问题可以描述为:有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。每件物品都有无限个(也就是可以放入背包多次),求解将哪些物品装入背包里物品价值总和最大。依然假设背包最大重量为4。

在这里插入图片描述

  为了保证每个物品仅被添加一次,01背包内嵌的循环是从大到小遍历。而完全背包的物品是可以添加多次的,所以要从小到大去遍历。

// 先遍历物品,再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);}
}

9.4 多重背包

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

  我们将物品数量摊开,其实可以将多重背包问题转换成01背包。例如:背包最大重量为10。物品的重量、价值和数量如下。那么可以转化成7个物品,每个物品只能用一次。这样就是一个01背包问题。因此我们在01背包的基础之上加上遍历个数即可。

在这里插入图片描述

#include<iostream>
#include<vector>
using namespace std;class Solution {
public:int Multip_Bag(int bagWeight, int nItem, vector<int> weight, vector<int> value, vector<int> nums) {vector<int> dp(bagWeight + 1, 0);for (int i = 0; i < nItem; 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]);}}}return dp[bagWeight];}
};int main() {int bagWeight = 10, nItem = 3;vector<int> weight = {1, 3, 4}, value = {15, 20, 30}, nums = {2, 3, 2};Solution s1;int result = s1.Multip_Bag(bagWeight, nItem, weight, value, nums);cout << result << endl;system("pause");return 0;
}

十、图论

10.1 深度优先搜索

  DFS和BFS的区别

  • 深度优先搜索(Depth First Search, DFS)是沿着一个方向搜索,不到黄河不死心,直到遇到绝境了,搜不下去了,再换方向(回溯)。
  • 广度优先搜索(Breadth First Search, BFS)是先把本节点所连接的所有节点遍历一遍,走到下一个节点的时候,再把连接节点的所有节点遍历一遍,搜索的方向是四面八方的,因此被称为广度优先搜索。

  因为DFS搜索就一个方向,并且需要回溯,所以用递归来实现是最方便的。二叉树遍历的递归法是DFS,而二叉树遍历的迭代法是BFS。

void dfs(参数) {处理节点dfs(图,选择的节点); // 递归回溯,撤销处理结果
}

  回溯算法本质上也是一种DFS过程,DFS搜索过程可以笼统的划分为三步。一是确定输入参数;二是确定终止条件;三是处理目前搜索节点的出发路径。

void dfs(输入参数) {if (终止条件) {存放结果;return;}for (选择:本节点所连接的其他节点) {处理节点;dfs(图,选择的节点); // 递归回溯,撤销处理结果}
}

10.2 广度优先搜索

  如果说深搜是一条路跑到黑然后再回溯的搜索方式,那么广搜就是一圈一圈的搜索过程。广搜的搜索方式就适合解决两个点之间最短路径的问题。因为广搜是从起点出发,以起始点为中心一圈一圈进行搜索,一旦遇到终点,记录之前走过的节点就是一条最短路。

10.3 并查集

  并查集是当我们需要判断两个元素是否在同一个集合里的时候,我们就要想到用并查集。并查集常用来解决连通性问题。并查集有以下两个功能:

  • 将两个元素添加到一个集合中。
  • 判断两个元素在不在同一个集合。

  设想我们将三个元素A, B,C(都是int类型)放在同一集合,其实就是将三个元素连通在一起。只需要一个一维数组来表示:father[A] = B, father[B] = C,father[C] = C。当我们使用find函数去寻找数组的元素,如果数组元素的根相同,这样就表示A与B与C连通。

// 将v,u 这条边加入并查集
void join(int u, int v) {u = find(u); // 寻找u的根v = find(v); // 寻找v的根if (u == v) return; // 如果发现根相同,则说明在一个集合,不同两个节点相连直接返回father[v] = u;
}

  find函数通过数组下标找到数组元素,一层一层寻根过程,代码如下:

// 并查集里寻根的过程
int find(int u) {if (u == father[u]) return u; // 如果根就是自己,直接返回else return find(father[u]); // 如果根不是自己,就根据数组下标一层一层向下找
}

  find函数寻根的过程是通过递归的方式,不断获取father数组下标对应的数值,最终找到集合的根。而这很像在一个多叉树中,从叶子节点出发,找到根节点的过程。如果说这颗树的高度很深,每次寻根需要递归很多次。

在这里插入图片描述

  而我们的目的是需要知道这些节点在同一个根下就可以,因此让多茶树的叶子节点直接指向根即可,每次寻根只需要一次。

在这里插入图片描述

  要实现这样的路径压缩过程,只需要在递归过程中,让father[u]接住 递归函数 find(father[u])的返回结果。这样是让u的父节点直接变成find函数返回的根节点。进一步可以用三元表达式精简代码。

// 并查集里寻根的过程
int find(int u) {if (u == father[u]) return u;else return father[u] = find(father[u]); // 路径压缩
}
int find(int u) {return u == father[u] ? u : father[u] = find(father[u]);
}

  同时,father数组初始化的时候要令 father[i] = i,默认指向自己。

// 并查集初始化
void init() {for (int i = 0; i < n; ++i) {father[i] = i;}
}

  如果通过find函数找到两个元素属于同一个根的话,那么这两个元素就是同一个集合,代码如下:

// 判断 u 和 v是否找到同一个根
bool isSame(int u, int v) {u = find(u);v = find(v);return u == v;
}

  结合以上加入并查集join、寻根find、初始化init和判断是否同一集合isSame函数,我们就得到一个并查集完整模板

int n = 1005; // n根据题目中节点数量而定,一般比节点数量大一点就好
vector<int> father = vector<int> (n, 0); // C++里的一种数组结构// 并查集初始化
void init() {for (int i = 0; i < n; ++i) {father[i] = i;}
}
// 并查集里寻根的过程
int find(int u) {return u == father[u] ? u : father[u] = find(father[u]); // 路径压缩
}// 判断 u 和 v是否找到同一个根
bool isSame(int u, int v) {u = find(u);v = find(v);return u == v;
}// 将v->u 这条边加入并查集
void join(int u, int v) {u = find(u); // 寻找u的根v = find(v); // 寻找v的根if (u == v) return ; // 如果发现根相同,则说明在一个集合,不同两个节点已经相连,直接返回father[v] = u;
}

  总结下来,并查集主要具有三个功能:

  • 1、寻找根节点函数find(int u),也就是判断这个节点的祖先节点是哪个;
  • 2、将两个节点接入到同一集合,join(int u, int v)函数,可以将两个节点连接在同一根节点上;
  • 3、判断两个节点是否在同一集合中,使用isSame(int u, int v)函数,就是判断两个节点是不是同一个根节点。

  复杂度分析

  • 时间复杂度: O ( 1 ) O(1) O(1),真实的复杂度在 O ( l o g n ) O(logn) O(logn) O ( 1 ) O(1) O(1)之间,且随着查询或者合并操作的增加,时间复杂度越来越趋近于 O ( 1 ) O(1) O(1)
  • 空间复杂度: O ( n ) O(n) O(n), 申请一个father数组。

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

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

相关文章

【C++】类和对象---友元,内部类,匿名对象详解

目录 友元 友元函数 友元类 内部类 匿名对象 ⭐友元 友元提供了一种突破封装的方式&#xff0c;有时提供了便利。但是友元会增加耦合度&#xff0c;破坏了封装&#xff0c;所以 友元不宜多用。 友元分为&#xff1a;友元函数和友元类。 ⚡友元函数 先看一个问题&#x…

使用 yarn 的时候,遇到 Error [ERR_REQUIRE_ESM]: require() of ES Module 怎么解决?

晚上回到家&#xff0c;我打开自己的项目&#xff0c;执行&#xff1a; cd HexoPress git pull --rebase yarn install yarn dev拉取在公司 push 的代码&#xff0c;然后更新依赖&#xff0c;最后开始今晚的开发时候&#xff0c;意外发生了&#xff0c;竟然报错了&#xff0c;…

Python流程控制有知道的吗?

流程控制是编程的核心概念之一&#xff0c;Python也不例外。在Python中&#xff0c;程序的流程控制结构主要包括顺序结构、选择结构和循环结构。这些结构让程序员能够更好地组织代码&#xff0c;使其按照特定的逻辑执行。 1.顺序结构 顺序结构是Python中最简单的流程控制结构&…

Android相机调用-libusbCamera【外接摄像头】【USB摄像头】 【多摄像头预览】

有的自定义系统&#xff0c;对于自己外接的USB摄像头&#xff0c;android原生的camera和camera2都无法打开&#xff0c;CameraX也用不了。这时候就要用libusbCamera&#xff0c;这个库可以打开摄像头&#xff0c;还可以多摄像头同时预览。本文主要是同时打开3个USB摄像头的项目…

Spring Boot应用集成Actuator组件以后怎么自定义端点暴露信息

一、 前言 在平时业务开发中&#xff0c;我们往往会在spring Boot项目中集成Actuator组件进行系统监控&#xff0c;虽然Actuator组件暴露的端点信息已经足够丰富了&#xff0c;但是特殊场景下&#xff0c;我们也需要自己暴露端点信息&#xff0c;此时应该怎么操作呢&#xff1…

爬虫知识--03

数据存mysql import requests from bs4 import BeautifulSoup import pymysql# 链接数据库pymysql conn pymysql.connect(userroot,password"JIAJIA",host127.0.0.1,databasecnblogs,port3306, ) cursor conn.cursor() cursor conn.cursor()# 爬数据 res request…

如何解决Nginx启动出现闪退问题?

哈喽&#xff0c;大家好&#xff0c;我是小浪。那么大家首次在启动nginx的时候&#xff0c;绝大部分同学会出现以下情况&#xff0c;就是我们双击nginx.exe文件之后&#xff0c;屏幕闪退一下就没了&#xff0c;然后我们访问localhost:8080提示404. 那么出现这种情况其实是我们…

NestJS入门7:增加异常过滤器

前文参考&#xff1a; NestJS入门1 NestJS入门2&#xff1a;创建模块 NestJS入门3&#xff1a;不同请求方式前后端写法 NestJS入门4&#xff1a;MySQL typeorm 增删改查 NestJS入门5&#xff1a;加入Swagger NestJS入门6&#xff1a;日志中间件 本文代码基于上一篇文章《…

深度学习基础(二)卷积神经网络(CNN)

之前的章节我们初步介绍了深度学习相关基础知识和训练神经网络&#xff1a; 深度学习基础&#xff08;一&#xff09;神经网络基本原理-CSDN博客文章浏览阅读924次&#xff0c;点赞13次&#xff0c;收藏19次。在如今的科技浪潮中&#xff0c;神经网络作为人工智能的核心技术之…

关于git子模块实践(一)

背景 在日常项目开发中&#xff0c;随着项目的迭代&#xff0c;不可避免的是主项目会引入到很多三方库&#xff0c;或者自研的一些模块。有一种场景&#xff0c;就是这些模块&#xff0c;是随着开发而进行迭代&#xff0c;且多个项目公用的&#xff0c;这种情况&#xff0c;在…

第3.3章:StarRocks数据导入——Stream Load

一、概述 Stream Load是StarRocks最为核心的导入方式&#xff0c;用户通过发送HTTP请求将本地文件或数据流导入至StarRocks中&#xff0c;其本身不依赖其他组件。 Stream Load支持csv和json两种数据文件格式&#xff0c;适用于数据文件数量较少且单个文件的大小不超过10GB 的场…

v-rep插件

v-rep官网插件汉化教程 官网教程 插件是什么 插件本质上就是遵循一定规范的API编写出来的程序&#xff0c;在v-rep中最终需要编译为动态库。 linux下是libsimXXXX.so&#xff1b; 其中XXXX是插件的名称。 请至少使用4个字符&#xff0c;并且不要使用下划线&#xff0c;因为…

kafka生产者2

1.数据可靠 • 0&#xff1a;生产者发送过来的数据&#xff0c;不需要等数据落盘应答。 风险&#xff1a;leader挂了之后&#xff0c;follower还没有收到消息。。。。 • 1&#xff1a;生产者发送过来的数据&#xff0c;Leader收到数据后应答。 风险&#xff1a;leader应答…

【机器学习】数据清洗——基于Numpy库的方法删除重复点

&#x1f388;个人主页&#xff1a;豌豆射手^ &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏 &#x1f917;收录专栏&#xff1a;机器学习 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共同学习、交流进…

PostgreSQL索引篇 | BTree

B-Tree索引 &#xff08;本文为《PostgreSQL数据库内核分析》一书的总结笔记&#xff0c;需要电子版的可私信我&#xff09; B树特点&#xff1a; 非叶子节点含一个或多个关键字值和子节点指针&#xff0c;不指向实际数据的存储位置所有关键字都是叶子节点&#xff0c;每个叶…

Python运算符你学会了吗?

1.算术运算符 &#xff08;加&#xff09;、-&#xff08;减&#xff09;、*&#xff08;乘&#xff09;、/&#xff08;除&#xff09;、%&#xff08;取余&#xff09;、//&#xff08;取整&#xff09;、**&#xff08;求幂&#xff09; a 12 b 3 c 7print(a b) # 15 …

关于Kinect 互动沙盘 深度图 Shader Graph 分层

把Kinect的深度图穿给Shader Graph using com.rfilkov.kinect; using UnityEngine; using UnityEngine.UI; public class GetDepthTex : MonoBehaviour { public Material Mat_SandTable; void Update() { Mat_SandTable.SetTexture("_MainTex"…

【openGL教程08】关于着色器(02)

LearnOpenGL - Shaders 一、说明 着色器是openGL渲染的重要内容&#xff0c;客户如果想自我实现渲染灵活性&#xff0c;可以用着色器进行编程&#xff0c;这种程序小脚本被传送到GPU的显卡内部&#xff0c;起到动态灵活的着色作用。 二、着色器简述 正如“Hello Triangle”一章…

【寸铁的刷题笔记】树、dfs、bfs、回溯、递归(二)

【寸铁的刷题笔记】树、dfs、bfs、回溯、递归(二) 大家好 我是寸铁&#x1f44a; 金三银四&#xff0c;树、dfs、bfs、回溯、递归是必考的知识点✨ 快跟着寸铁刷起来&#xff01;面试顺利上岸&#x1f44b; 喜欢的小伙伴可以点点关注 &#x1f49d; 上期回顾 感谢大家的支持&am…

[附完整代码]群智能算法跑21种真实世界优化问题,并输出结果到excel||群智能算法跑CEC 2020真实世界优化问题,并输出结果到excel

1、简介 灰狼算法跑跑21种真实世界优化问题|足球训练队优化算法跑21种真实世界优化问题||牛顿拉夫逊算法跑21种真实世界优化问题||冠状豪猪CPO跑21种真实世界优化问题。 ‘FTTA’,‘BWO’, ‘CPO’, ‘FHO’, ‘GWO’, ‘HHO’, ‘NRBO’,‘SCA’,‘SGA’,WOA’跑21种真实世…