任务执行拓扑排序（华为od机考题）

server/2024/9/20 1:21:56/ 标签: 算法, 数据结构, 华为od, java, 排序算法

一、题目

1.原题

一个应用启动时，会有多个初始化任务需要执行，
并且任务之间有依赖关系，
例如：A任务依赖B任务，那么必须在B任务执行完成之后，才能开始执行A任务。
现在给出多条任务依赖关系的规则，请输入任务的顺序执行序列，
规则采用贪婪策略，即一个任务如果没有依赖的任务，则立刻开始执行，
如果同时有多个任务要执行，则根据任务名称字母顺序排序。
例如：B任务依赖A任务，C任务依赖A任务，D任务依赖B任务和C任务，同时，D任务还依赖E任务。
那么执行任务的顺序由先到后是：A任务，E任务，B任务，C任务，D任务。
这里A和E任务都是没有依赖的，立即执行。
 

2.题目理解

考点：[数组, 树, DFS搜索]

拓扑排序问题，通过建立任务之间的依赖关系图，然后按照一定规则执行任务，即先执行没有依赖的任务，然后再执行依赖于前面任务的任务。

二、思路与代码过程

1.思路

多任务依赖关系的规则：贪婪策略，一个任务如果没有依赖的任务，则立刻开始执行，若同时有多个任务要执行，则根据任务名称字母顺序排序；

输入：H->F,Y->H ,B->Y ,Y->M ,M->L ,L->T

输出：F T H L M Y B

对输入进行拆分，对依赖关系进行建表，使用outdegree和depend来描述依赖关系；

首先将outdegree为0的存入队列中，当队列不为空的时候，进行从队列q中移除加入已执行任务列表中Execute；

当处理完一轮之后，若上一轮产生了outdegree为0的任务则将其加入处理队列，若未产生则按照字典顺序依次处理任务；

直到没有新的可加入，队列为空，输出执行列表Excute，若Excute长度不等于任务总数则表示该系列任务存在回路，无法全部完成，若相等则执行完毕，输出执行顺序。

2.代码过程

①main函数

public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入任务依赖关系的数量：");int n = sc.nextInt();System.out.println("请输入任务之间的依赖关系：");ArrayList<String[]> task = new ArrayList<>();for (int i = 0; i < n; i++) {String[] s = sc.next().split("->");task.add(s);}Collections.sort(task, new Comparator<String[]>() {@Overridepublic int compare(String[] a, String[] b) {// 以第一个元素进行比较return a[0].compareTo(b[0]);}});Set<String> set = new TreeSet<>();for (int i = 0; i < n; i++) {set.add(task.get(i)[0]);set.add(task.get(i)[1]);}Map<String,Node> NodeTask = new HashMap<>();for (String s : set) {NodeTask.put(s,new Node(s,0,new ArrayList<>()));for (String[] t : task) {if (s.equals(t[0])) {Node node = NodeTask.get(s);node.outdegree++;//出度：->后有元素，即存在依赖node.depend.add(t[1]);//添加->后的元素，即添加依赖项//依赖者->被依赖者}}}TreeMap<String, Node> sortedNodeTask = new TreeMap<>(NodeTask);ArrayList<String> Execute = new ArrayList<>();//使用队列进行遍历Queue<String> q = new LinkedList<>();//初始化队列for (Node node : sortedNodeTask.values()) {if (node.outdegree == 0) {q.add(node.name);}}//创建函数ArrayList<String>ExecuteOrder = TaskCal(q,Execute,sortedNodeTask,set);if (Execute.size() != set.size()) {System.out.println("图中存在环路，无法完成拓扑排序。");}else {System.out.println("任务的执行顺序为：");System.out.println(Execute);}}

②TaskCal函数

private static ArrayList<String> TaskCal(Queue<String> q, ArrayList<String> execute, TreeMap<String, Node> sortedNodeTask, Set<String> set) {//先处理无依赖的点，因为无环所以必存在一个无依赖点//入队后，除依赖处理while(!q.isEmpty()){boolean newAdd = false;String current = q.poll();//移除execute.add(current);//加入已执行队列Node currentNode = sortedNodeTask.get(current);//遍历找到依赖于当前节点的任务，移除依赖for (Node node : sortedNodeTask.values()) {if(node.depend.contains(current)){node.outdegree--;node.depend.remove(current);}}for (Node node : sortedNodeTask.values()) {if (node.outdegree == 0&&!q.contains(node.name)&&!execute.contains(node.name)) {//队列检验1q.add(node.name);newAdd = true;//队列检验2}}if (!newAdd&&execute.size()<set.size()&&q.isEmpty()){ArrayList<String> tmp = new ArrayList<>(set);for (String key : execute) {tmp.remove(key);}q.add(tmp.get(0));//队列加入未处理字母中的第一个值，按照顺序慢慢处理}}return execute;}

③Node类

public static class Node {String name;int outdegree;ArrayList<String> depend;public Node(String name, int outdegree, ArrayList<String> depend) {this.name = name;this.outdegree = outdegree;this.depend = depend;}public String toString() {return "Node{" +"name='" + name + '\'' +", outdegree=" + outdegree +", depend=" + depend +'}';}}

三、运行结果

1.运行截图

2.带数据分析运行结果

请输入任务依赖关系的数量：
6
请输入任务之间的依赖关系：
H->F
Y->H
B->Y
Y->M
M->L
L->T
task:
[B, Y]
[H, F]
[L, T]
[M, L]
[Y, H]
[Y, M]
set:[B, F, H, L, M, T, Y]
sortedNodeTask:
Node{name='B', outdegree=1, depend=[Y]}
Node{name='F', outdegree=0, depend=[]}
Node{name='H', outdegree=1, depend=[F]}
Node{name='L', outdegree=1, depend=[T]}
Node{name='M', outdegree=1, depend=[L]}
Node{name='T', outdegree=0, depend=[]}
Node{name='Y', outdegree=2, depend=[H, M]}
1 element:F
1 element:T
q队列循环：
q拿出的currentNode:Node{name='F', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=1, depend=[Y]}
current0:F
依赖判断0:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:F
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=1, depend=[F]}
current0:F
依赖判断0:Node{name='H', outdegree=1, depend=[F]}node.depend:[F]
---------------------------current1:F
依赖判断1:Node{name='H', outdegree=1, depend=[F]}node.depend:[F]
--------------------------依赖移除后:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=1, depend=[T]}
current0:F
依赖判断0:Node{name='L', outdegree=1, depend=[T]}node.depend:[T]
sortedNodeTask循环:Node{name='M', outdegree=1, depend=[L]}
current0:F
依赖判断0:Node{name='M', outdegree=1, depend=[L]}node.depend:[L]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:F
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=2, depend=[H, M]}
current0:F
依赖判断0:Node{name='Y', outdegree=2, depend=[H, M]}node.depend:[H, M]
2 qele:T
3 qele:T
3 qele:H
4 qele:T
4 qele:H
q队列循环：
q拿出的currentNode:Node{name='T', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=1, depend=[Y]}
current0:T
依赖判断0:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:T
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=0, depend=[]}
current0:T
依赖判断0:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=1, depend=[T]}
current0:T
依赖判断0:Node{name='L', outdegree=1, depend=[T]}node.depend:[T]
---------------------------current1:T
依赖判断1:Node{name='L', outdegree=1, depend=[T]}node.depend:[T]
--------------------------依赖移除后:Node{name='L', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='M', outdegree=1, depend=[L]}
current0:T
依赖判断0:Node{name='M', outdegree=1, depend=[L]}node.depend:[L]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:T
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=2, depend=[H, M]}
current0:T
依赖判断0:Node{name='Y', outdegree=2, depend=[H, M]}node.depend:[H, M]
2 qele:H
3 qele:H
3 qele:L
4 qele:H
4 qele:L
q队列循环：
q拿出的currentNode:Node{name='H', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=1, depend=[Y]}
current0:H
依赖判断0:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:H
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=0, depend=[]}
current0:H
依赖判断0:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=0, depend=[]}
current0:H
依赖判断0:Node{name='L', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='M', outdegree=1, depend=[L]}
current0:H
依赖判断0:Node{name='M', outdegree=1, depend=[L]}node.depend:[L]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:H
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=2, depend=[H, M]}
current0:H
依赖判断0:Node{name='Y', outdegree=2, depend=[H, M]}node.depend:[H, M]
---------------------------current1:H
依赖判断1:Node{name='Y', outdegree=2, depend=[H, M]}node.depend:[H, M]
--------------------------依赖移除后:Node{name='Y', outdegree=1, depend=[M]}node.depend:[M]
4 qele:L
q队列循环：
q拿出的currentNode:Node{name='L', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=1, depend=[Y]}
current0:L
依赖判断0:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:L
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=0, depend=[]}
current0:L
依赖判断0:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=0, depend=[]}
current0:L
依赖判断0:Node{name='L', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='M', outdegree=1, depend=[L]}
current0:L
依赖判断0:Node{name='M', outdegree=1, depend=[L]}node.depend:[L]
---------------------------current1:L
依赖判断1:Node{name='M', outdegree=1, depend=[L]}node.depend:[L]
--------------------------依赖移除后:Node{name='M', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:L
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=1, depend=[M]}
current0:L
依赖判断0:Node{name='Y', outdegree=1, depend=[M]}node.depend:[M]
3 qele:M
4 qele:M
q队列循环：
q拿出的currentNode:Node{name='M', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=1, depend=[Y]}
current0:M
依赖判断0:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:M
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=0, depend=[]}
current0:M
依赖判断0:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=0, depend=[]}
current0:M
依赖判断0:Node{name='L', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='M', outdegree=0, depend=[]}
current0:M
依赖判断0:Node{name='M', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:M
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=1, depend=[M]}
current0:M
依赖判断0:Node{name='Y', outdegree=1, depend=[M]}node.depend:[M]
---------------------------current1:M
依赖判断1:Node{name='Y', outdegree=1, depend=[M]}node.depend:[M]
--------------------------依赖移除后:Node{name='Y', outdegree=0, depend=[]}node.depend:[]
3 qele:Y
4 qele:Y
q队列循环：
q拿出的currentNode:Node{name='Y', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=1, depend=[Y]}
current0:Y
依赖判断0:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
---------------------------current1:Y
依赖判断1:Node{name='B', outdegree=1, depend=[Y]}node.depend:[Y]
--------------------------依赖移除后:Node{name='B', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:Y
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=0, depend=[]}
current0:Y
依赖判断0:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=0, depend=[]}
current0:Y
依赖判断0:Node{name='L', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='M', outdegree=0, depend=[]}
current0:Y
依赖判断0:Node{name='M', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:Y
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=0, depend=[]}
current0:Y
依赖判断0:Node{name='Y', outdegree=0, depend=[]}node.depend:[]
3 qele:B
4 qele:B
q队列循环：
q拿出的currentNode:Node{name='B', outdegree=0, depend=[]}
sortedNodeTask循环:Node{name='B', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='B', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='F', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='F', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='H', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='H', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='L', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='L', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='M', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='M', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='T', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='T', outdegree=0, depend=[]}node.depend:[]
sortedNodeTask循环:Node{name='Y', outdegree=0, depend=[]}
current0:B
依赖判断0:Node{name='Y', outdegree=0, depend=[]}node.depend:[]
7 7
任务的执行顺序为：

[F, T, H, L, M, Y, B]

3.带数据分析完整代码

import java.util.*;public class test40 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入任务依赖关系的数量：");int n = sc.nextInt();System.out.println("请输入任务之间的依赖关系：");ArrayList<String[]> task = new ArrayList<>();for (int i = 0; i < n; i++) {String[] s = sc.next().split("->");task.add(s);}Collections.sort(task, new Comparator<String[]>() {@Overridepublic int compare(String[] a, String[] b) {// 以第一个元素进行比较return a[0].compareTo(b[0]);}});System.out.println("task:");for (String[] s : task) {System.out.println(Arrays.toString(s));}Set<String> set = new TreeSet<>();for (int i = 0; i < n; i++) {set.add(task.get(i)[0]);set.add(task.get(i)[1]);}System.out.println("set:"+set);//无意义?Map<String,Node> NodeTask = new HashMap<>();for (String s : set) {NodeTask.put(s,new Node(s,0,new ArrayList<>()));for (String[] t : task) {if (s.equals(t[0])) {Node node = NodeTask.get(s);node.outdegree++;//出度：->后有元素，即存在依赖node.depend.add(t[1]);//添加->后的元素，即添加依赖项//依赖者->被依赖者}}}TreeMap<String, Node> sortedNodeTask = new TreeMap<>(NodeTask);System.out.println("sortedNodeTask:");for (Node node : sortedNodeTask.values()) {System.out.println(node);}ArrayList<String> Execute = new ArrayList<>();//使用队列进行遍历Queue<String> q = new LinkedList<>();//初始化队列for (Node node : sortedNodeTask.values()) {if (node.outdegree == 0) {q.add(node.name);}}for (String element : q) {System.out.println("1 element:"+element);}//创建函数ArrayList<String>ExecuteOrder = TaskCal(q,Execute,sortedNodeTask,set);//System.out.println(Execute.size()+" "+set.size());if (Execute.size() != set.size()) {System.out.println("图中存在环路，无法完成拓扑排序。");}else {System.out.println("任务的执行顺序为：");for (String s : Execute) {System.out.println(s);}}System.out.println("任务的顺序执行序列为;");for (String s : Execute) {System.out.println(s);}}private static ArrayList<String> TaskCal(Queue<String> q, ArrayList<String> execute, TreeMap<String, Node> sortedNodeTask, Set<String> set) {//先处理无依赖的点，因为无环所以必存在一个无依赖点//入队后，除依赖处理while(!q.isEmpty()){boolean newAdd = false;System.out.println("q队列循环：");String current = q.poll();//移除execute.add(current);//加入已执行队列Node currentNode = sortedNodeTask.get(current);System.out.println("q拿出的currentNode:"+currentNode);//遍历找到依赖于当前节点的任务，移除依赖for (Node node : sortedNodeTask.values()) {System.out.println("sortedNodeTask循环:"+node);System.out.println("current0:"+current);System.out.println("依赖判断0:"+node+"node.depend:"+node.depend);if(node.depend.contains(current)){System.out.println("---------------------------current1:"+current);System.out.println("依赖判断1:"+node+"node.depend:"+node.depend);node.outdegree--;node.depend.remove(current);System.out.println("--------------------------依赖移除后:"+node+"node.depend:"+node.depend);}}for (Node node : sortedNodeTask.values()) {if (node.outdegree == 0&&!q.contains(node.name)&&!execute.contains(node.name)) {//队列检验1for (String element : q) {System.out.println("2 qele:"+element);}q.add(node.name);newAdd = true;//队列检验2for (String element : q) {System.out.println("3 qele:"+element);}}}if (!newAdd&&execute.size()<set.size()&&q.isEmpty()){System.out.println("======================================================字典序处理！");ArrayList<String> tmp = new ArrayList<>(set);for (String key : execute) {tmp.remove(key);}q.add(tmp.get(0));//队列加入未处理字母中的第一个值，按照顺序慢慢处理}for (String element : q) {System.out.println("4 qele:"+element);}}return execute;}public static class Node {String name;int outdegree;ArrayList<String> depend;public Node(String name, int outdegree, ArrayList<String> depend) {this.name = name;this.outdegree = outdegree;this.depend = depend;}public String toString() {return "Node{" +"name='" + name + '\'' +", outdegree=" + outdegree +", depend=" + depend +'}';}}
}


http://www.ppmy.cn/server/113753.html

相关文章

银行定期产品

银行定期产品

银行存款产品如下： 其中对私的储蓄存款： 定期存款是指存款人在银行或金融机构存入一定金额的资金，并约定一个固定的存期，在存期内不得随意支取，到期后可以获取本金和预先约定好的利息的一种存款方式。根据不同的存取方式和特点，定期存款主要可以分为以下几种类型： 整存…
阅读更多...
Redis进阶（二）--Redis高级特性和应用

Redis进阶（二）--Redis高级特性和应用

文章目录 第二章、Redis高级特性和应用一、Redis的慢查询1、慢查询配置2、慢查询操作命令3、慢查询建议 二、Pipeline三、事务1、Redis的事务原理2、Redis的watch命令3、Pipeline和事务的区别 四、Lua1、Lua入门&#xff08;1&#xff09;安装Lua&#xff08;2&#xff09;Lua基…
阅读更多...
无人机纪录片航拍认知

无人机纪录片航拍认知

写在前面 博文内容为纪录片航拍简单认知&#xff1a;纪录片 航拍镜头&#xff0c;航拍流程&#xff0c;航拍环境条件注意事项介绍航拍学习书籍推荐《无人机商业航拍教程》读书笔记整理&#xff0c;适合小白认知理解不足小伙伴帮忙指正 &#x1f603;,生活加油 99%的焦虑都来自于…
阅读更多...
堆-数组的堆化+优先队列（PriorityQueue）的使用

堆-数组的堆化+优先队列（PriorityQueue）的使用

一、堆 1、什么是堆&#xff1f; 以完全二叉树的形式将元素存储到对应的数组位置上所形成的新数组 2、为什么要将数组变成堆&#xff1f; 当数组中的元素连续多次进行排序时会消耗大量的时间&#xff0c;将数组变成堆后通过堆排序的方式将会消耗更少的时间 二、接口 给堆…
阅读更多...
OpenSSL Windows编译

OpenSSL Windows编译

目录 1. 源码下载2. vs2022编译 1. 源码下载 源码地址 2. vs2022编译 (1) 将“VS2022安装目录VC\Auxiliary\Build\“设置为PATH环境变量&#xff0c;启动cmd命令行&#xff08;一定要先设置环境变量&#xff09;。 (2)在cmd下进入VS2013安装目录vs2022\VC\Auxiliary\Build&…
阅读更多...
心觉：潜意识是一个免费的“超级工作狂”，你居然不会用

心觉：潜意识是一个免费的“超级工作狂”，你居然不会用

我们常听说&#xff1a;潜意识的力量是意识到3万倍以上 你信吗 估计很多人不相信&#xff0c;不相信当然用不好 不相信的原因核心有两个&#xff1a; 没有体验过 寻求绝对的科学验证 这两个原因会让你对潜意识不相信&#xff0c;或者半信半疑 今天我也不会给你绝对的科学…
阅读更多...
要在 Windows 系统中通过 VNC 远程连接到 CentOS 或 Ubuntu 服务器，可以按照以下步骤来配置和使用 VNC 进行远程桌面访问

要在 Windows 系统中通过 VNC 远程连接到 CentOS 或 Ubuntu 服务器，可以按照以下步骤来配置和使用 VNC 进行远程桌面访问

要在 Windows 系统中通过 VNC 远程连接到 CentOS 或 Ubuntu 服务器&#xff0c;可以按照以下步骤来配置和使用 VNC 进行远程桌面访问。 在 CentOS 或 Ubuntu 服务器上配置 VNC 服务 步骤 1&#xff1a;安装 VNC 服务器和桌面环境 对于 CentOS&#xff1a; 安装桌面环境&…
阅读更多...
江协科技STM32学习- P9 OLED调试工具

江协科技STM32学习- P9 OLED调试工具

&#x1f680;write in front&#x1f680; &#x1f50e;大家好&#xff0c;我是黄桃罐头&#xff0c;希望你看完之后&#xff0c;能对你有所帮助&#xff0c;不足请指正&#xff01;共同学习交流 &#x1f381;欢迎各位→点赞&#x1f44d; 收藏⭐️ 留言&#x1f4dd;​…
阅读更多...
uni-app流式接受消息/文件

uni-app流式接受消息/文件

uni-app流式接受消息/文件 问题描述 今天利用fastgpt搭建了一个局域网进行访问Ai助理&#xff0c;在前端通过api接口进行请求&#xff0c;用于接收后端的发送的流式消息&#xff0c;那么前端可以进行流式的获取到这个消息&#xff0c;也可以进行直接进行在请求发送完成以后&a…
阅读更多...
大量数据相似度加速计算

大量数据相似度加速计算

背景 在实际工作中&#xff0c;有100万的数据&#xff0c;需要将100万条数据中&#xff0c;语义相似的聚合一起作为list&#xff0c;由于数据量过大&#xff0c;计算相似性耗时较久 例如&#xff1a; 合并后的数据 [[你好&#xff0c;你好啊&#xff0c;您好&#xff0c;hell…
阅读更多...
828华为云征文｜华为云Flexus云服务器X实例之openEuler系统下部署GitLab服务器

828华为云征文｜华为云Flexus云服务器X实例之openEuler系统下部署GitLab服务器

828华为云征文&#xff5c;华为云Flexus云服务器X实例之openEuler系统下部署Gitlab服务器 前言一、Flexus云服务器X实例介绍1.1 Flexus云服务器X实例简介1.2 Flexus云服务器X实例特点1.3 Flexus云服务器X实例使用场景 二、GitLab介绍2.1 GitLab简介2.2 GitLab主要特点 三、本次…
阅读更多...
深入理解C代码中的条件编译

深入理解C代码中的条件编译

引言 条件编译是 C 编程中的一个重要特性&#xff0c;它允许开发人员根据不同的条件选择性地编译源代码的不同部分。这一特性对于编写跨平台的程序、优化代码性能或控制编译时资源消耗等方面非常重要。本文将深入探讨条件编译的工作原理、使用场景、高级应用以及注意事项&…
阅读更多...
【Python机器学习】词向量推理——词向量

【Python机器学习】词向量推理——词向量

目录 面向向量的推理 使用词向量的更多原因 如何计算Word2vec表示 skip-gram方法 什么是softmax 神经网络如何学习向量表示 用线性代数检索词向量 连续词袋方法 skip-gram和CBOW&#xff1a;什么时候用哪种方法 word2vec计算技巧 高频2-gram 高频词条降采样 负采样…
阅读更多...
Apache DolphinScheduler在Cisco Webex的应用与优化实践

Apache DolphinScheduler在Cisco Webex的应用与优化实践

引言 我叫李庆旺&#xff0c;是Cisco Webex的一名软件工程师&#xff0c;同时也是Apache DolphinScheduler&#xff08;以下简称DS&#xff09;的Committer。 在过去的两年里&#xff0c;公司基于Apache DolphinScheduler进行了多项持续改进和创新&#xff0c;以更好地适应我们…
阅读更多...
react、vue 提供的 hook 函数对比

react、vue 提供的 hook 函数对比

文章目录 useMemo vs computeduseEffect vs watch useMemo vs computed React 的useMemo 和 Vue3 的computed 分别用于优化性能和避免不必要的计算的两个概念。它们的目标相似&#xff0c;但实现方式和使用场景有所不同。它们都用于优化那些依赖于其他状态或属性&#xff0c;并…
阅读更多...
string字符会调用new分配堆内存吗

string字符会调用new分配堆内存吗

gcc的string默认大小是32个字节&#xff0c;字符串小于等于15直接保存在栈上&#xff0c;超过之后才会使用new分配。
阅读更多...
Mac使用Elasticsearch

Mac使用Elasticsearch

下载 Past Releases of Elastic Stack Software | Elastic 解压tar -xzvf elasticsearch-8.15.1-darwin-x86_64.tar.gz 修改配置文件config/elasticsearch.yml xpack.security.enabled: false xpack.security.http.ssl: enabled: false 切换目录 cd elasticsearch-8.15.1/…
阅读更多...
【React】Vite 构建 React

【React】Vite 构建 React

项目搭建 vite 官网&#xff1a;Vite 跟着文档走即可&#xff0c;选择 react &#xff0c;然后 ts swc。 着重说一下 package-lock.json 这个文件有两个作用&#xff1a; 锁版本号&#xff08;保证项目在不同人手里安装的依赖都是相同的&#xff0c;解决版本冲突的问题&am…
阅读更多...
基于SpringBoot校园快递代取系统

基于SpringBoot校园快递代取系统

基于springbootvue实现的校园快递代取系统&#xff08;源码L文ppt&#xff09;4-049 3系统设计 3.1.1系统结构图 系统结构图可以把杂乱无章的模块按照设计者的思维方式进行调整排序&#xff0c;可以让设计者在之后的添加&#xff0c;修改程序内容…
阅读更多...
解析 MySQL 数据库的 Python 接口：`mysqlclient` 与 `django-mysql` 实战指南20240904

解析 MySQL 数据库的 Python 接口：`mysqlclient` 与 `django-mysql` 实战指南20240904

博客标题&#xff1a;深入解析 MySQL 数据库的 Python 接口&#xff1a;mysqlclient 与 django-mysql 实战指南 引言 在现代 Web 开发中&#xff0c;数据库与应用程序的交互是不可避免的核心环节。对于使用 Python 尤其是 Django 框架的开发者来说&#xff0c;如何有效地与 M…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站