建设局域网网站/个人网站

建设局域网网站,个人网站,网站建设上市公司,wordpress httpd.ini本篇适用于ZZU的编译原理课程实验二——自动机实验：NFA转DFA并最小化，包含了实验代码和实验报告的内容，读者可根据需要参考完成自己的程序设计。 如果是ZZU的学弟学妹看到这篇，那么恭喜你，你来对地方啦！ 如…

本篇适用于ZZU的编译原理课程实验二——自动机实验：NFA转DFA并最小化，包含了实验代码和实验报告的内容，读者可根据需要参考完成自己的程序设计。
如果是ZZU的学弟学妹看到这篇，那么恭喜你，你来对地方啦！
如果需要相关文档资料的话，我也已经上传，免费下载：「编译原理实验二代码+实验报告（ZZU）」

不要忘了点赞👍和收藏💌支持一下哦！

源代码

先给出实验的源代码

#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <sstream>
using namespace std;// NFA类定义
struct NFA {set<int> states;                    // 状态集合set<int> alphabet;                  // 字母表map<pair<int,int>, set<int>> transitions;  // 转移函数 F(fromState, symbol)={toStates}int start_state{};                  // 初始状态set<int> accept_states;             // 接受状态集合
};// DFA类定义
struct DFA {set<int> states;                    // 状态集合set<int> alphabet;                  // 字母表map<pair<int,int>, int> transitions; // 转移函数int start_state{};                    // 初始状态set<int> accept_states;             // 接受状态集合
};// 从文件读取NFA
NFA readNFAFromFile(const string& filename) {NFA nfa;ifstream file(filename);string line;// 读取状态集合getline(file, line);istringstream iss(line);    // 将一行数据转换成一个输入流，随后可以像处理文件或标准输入一样从`iss`中提取数据int state;while (iss >> state) {      // 从转换好后的每一行输入中，逐个读取整数作为状态`state`nfa.states.insert(state);}// 读取字母表getline(file, line);iss.clear();        // 重置流状态iss.str(line);      // 读取新的一行作为流int symbol;         // 输入的标志字母while (iss >> symbol) {nfa.alphabet.insert(symbol);}// 读取转移规则数量int trans_count;file >> trans_count;// 读取转移规则for (int i = 0; i < trans_count; i++) {int from_state, now_symbol;     // 当前状态，转换字母file >> from_state >> now_symbol; // 从文件中读取set<int> to_states_set; // 目标状态集合int to_state;   // 目标状态// 读取目标状态，添加到到目标状态集合while (file.get() != '\n' && file >> to_state) {to_states_set.insert(to_state);}nfa.transitions[{from_state, now_symbol}] = to_states_set; // 转移函数 F(fromState, symbol)={toState}}// 读取初始状态和接受状态file >> nfa.start_state;int accept_state;file >> accept_state;nfa.accept_states.insert(accept_state);return nfa;
}// 获取ε-闭包集合
set<int> getEpsilonClosure(const NFA& nfa, const set<int>& states) {set<int> closure = states;// 队列进行存储状态集合statesqueue<int> q;for (int state : states) {q.push(state);}while (!q.empty()) {// 从前往后弹出状态int current = q.front();q.pop();// 对每个状态进行判断闭包auto it = nfa.transitions.find({current, -1}); // 查找转换函数中的当前状态的所有ε边if (it != nfa.transitions.end()) {for (int next : it->second) {   // it中的元素为键值对类型pair，second就是获取键值对的后一个值if (closure.find(next) == closure.end()) { // 未被记录进闭包集合closure.insert(next);q.push(next);}}}}return closure;
}// 合并两个NFA
NFA mergeNFAs(const NFA& nfa1, const NFA& nfa2) {NFA merged;// 找到最大状态编号int max_state = 0;for (int state : nfa1.states) max_state = max(max_state, state);for (int state : nfa2.states) max_state = max(max_state, state);// 新的起始状态int new_start = max_state + 1;merged.start_state = new_start;// 合并状态集merged.states = nfa1.states;merged.states.insert(nfa2.states.begin(), nfa2.states.end());merged.states.insert(new_start);// 合并字母表merged.alphabet = nfa1.alphabet;merged.alphabet.insert(nfa2.alphabet.begin(), nfa2.alphabet.end());// 合并转移函数merged.transitions = nfa1.transitions;for (const auto& trans : nfa2.transitions) {merged.transitions[trans.first] = trans.second;}// 添加从新起始状态到原始NFA起始状态的ε转移merged.transitions[{new_start, -1}].insert(nfa1.start_state);merged.transitions[{new_start, -1}].insert(nfa2.start_state);// 合并接受状态merged.accept_states = nfa1.accept_states;merged.accept_states.insert(nfa2.accept_states.begin(), nfa2.accept_states.end());return merged;
}// NFA转换为DFA
DFA convertNFAtoDFA(const NFA& nfa) {DFA dfa;map<set<int>, int> dfa_states;  // nfa状态集 --> dfa的一个状态queue<set<int>> unprocessed_states;// 初始化DFAdfa.alphabet = nfa.alphabet;// 求DFA的起始状态set<int> initial_state = getEpsilonClosure(nfa, {nfa.start_state});dfa_states[initial_state] = 0;dfa.start_state = 0;unprocessed_states.push(initial_state); // 将dfa起始状态集加入已处理状态队列// 使用子集构造法构建DFAwhile (!unprocessed_states.empty()) {set<int> current_state = unprocessed_states.front();unprocessed_states.pop();int dfa_state = dfa_states[current_state];// 检查是否为接受状态for (int state : current_state) {if (nfa.accept_states.find(state) != nfa.accept_states.end()) {dfa.accept_states.insert(dfa_state);break;}}// 对每个输入符号构造转移for (int symbol : nfa.alphabet) {set<int> next_state;// 将当前状态的多条转移合并for (int state : current_state) {auto it = nfa.transitions.find({state, symbol});if (it != nfa.transitions.end()) {next_state.insert(it->second.begin(), it->second.end()); // 多条转移的终点合并加入到当前状态集合的目标状态集合// 实现多条转移合并为一条集合与集合之间的转移}}// 计算ε-闭包next_state = getEpsilonClosure(nfa, next_state);if (!next_state.empty()) {// 判断是否是新状态if (dfa_states.find(next_state) == dfa_states.end()) {int new_state = dfa_states.size(); // 为新状态进行编号dfa_states[next_state] = new_state;unprocessed_states.push(next_state);}dfa.transitions[{dfa_state, symbol}] = dfa_states[next_state];}}}// 设置DFA状态集for (const auto& state : dfa_states) {dfa.states.insert(state.second);}return dfa;
}// DFA最小化
DFA minimizeDFA(const DFA& dfa) {// 初始划分：接受状态和非接受状态vector<set<int>> partitions(2);map<int, int> partition_map;for (int state : dfa.states) {if (dfa.accept_states.find(state) != dfa.accept_states.end()) {partitions[0].insert(state);partition_map[state] = 0;} else {partitions[1].insert(state);partition_map[state] = 1;}}bool changed; // 标记划分是否改变do {changed = false;vector<set<int>> new_partitions; // 新的划分for (const auto& partition : partitions) {if (partition.size() <= 1) {new_partitions.push_back(partition);continue;}map<vector<int>, set<int>> subdivision; // 子划分for (int state : partition) {vector<int> parts; // 划分号for (int symbol : dfa.alphabet) {auto it = dfa.transitions.find({state, symbol});if (it != dfa.transitions.end()) {parts.push_back(partition_map[it->second]);} else {parts.push_back(-1);}}subdivision[parts].insert(state);}for (const auto& sub : subdivision) {new_partitions.push_back(sub.second);if (sub.second.size() != partition.size()) {changed = true;}}}// 发生了改变if (changed) {partitions = new_partitions;partition_map.clear();for (size_t i = 0; i < partitions.size(); i++) {for (int state : partitions[i]) {partition_map[state] = i;}}}} while (changed);// 构建最小化DFADFA min_dfa;min_dfa.alphabet = dfa.alphabet;// 映射旧状态到新状态map<int, int> state_map;int new_state_id = 0;for (const auto& partition : partitions) {for (int state : partition) {if (state_map.find(state) == state_map.end()) {state_map[state] = new_state_id;min_dfa.states.insert(new_state_id);if (state == dfa.start_state) {min_dfa.start_state = new_state_id;}if (dfa.accept_states.find(state) != dfa.accept_states.end()) {min_dfa.accept_states.insert(new_state_id);}new_state_id++;}}}// 构建新的转移函数for (const auto& trans : dfa.transitions) {int from_state = state_map[trans.first.first];int symbol = trans.first.second;int to_state = state_map[trans.second];min_dfa.transitions[{from_state, symbol}] = to_state;}return min_dfa;
}// 打印DFA
void printDFA(const DFA& dfa) {cout << "DFA\n";cout << "  状态集：{";for (auto it = dfa.states.begin(); it != dfa.states.end(); ++it) {if (it != dfa.states.begin()) cout << ",";cout << *it;}cout << "}\n";cout << "  符号表：{";for (auto it = dfa.alphabet.begin(); it != dfa.alphabet.end(); ++it) {if (it != dfa.alphabet.begin()) cout << ",";cout << *it;}cout << "}\n";cout << "  状态转换：\n";for (const auto& trans : dfa.transitions) {cout << "    (" << trans.first.first << "," << trans.first.second << ")->" << trans.second << "\n";}cout << "  开始状态：" << dfa.start_state << "\n";cout << "  结束状态集：{";for (auto it = dfa.accept_states.begin(); it != dfa.accept_states.end(); ++it) {if (it != dfa.accept_states.begin()) cout << ",";cout << *it;}cout << "}\n";
}int main() {// 从文件读取NFANFA nfa1 = readNFAFromFile("experiment02_input1.txt");NFA nfa2 = readNFAFromFile("experiment02_input2.txt");// 合并NFANFA merged_nfa = mergeNFAs(nfa1, nfa2);// 转换为DFADFA dfa = convertNFAtoDFA(merged_nfa);// 最小化DFADFA min_dfa = minimizeDFA(dfa);// 输出结果printDFA(min_dfa);return 0;
}

实验报告

接下来是实验报告的内容，希望能帮助读者理解词法分析程序的设计思路，以及完成实验报告的撰写。

一．实验目的

  1. 理解和掌握把问题中的实体转换成抽象模型中数据结构的能力，设计确定有穷自动机DFA和非确定有穷自动机NFA描述的对象模型或数据结构，实现DFA和NFA的基本操作（输入和输出）；
  2. 掌握将多个NFA合并的方法；
  3. 掌握将NFA确定化成DFA的方法；
  4. 掌握将DFA最小化的方法。
    加深对自动机的理解。

二．问题描述

  1. 需要实现的功能
    (1)设计一个函数（方法），实现把两个NFA的合并；
    (2)设计一个函数（方法），实现把NFA确定化成一个DFA；
    (3)设计一个函数（方法），实现把DFA最小化；
    (4)输入多个NFA：NFA描述存储在文本文件中，文件名作为命令行参数输入；
    (5)输出合并、最小化以后的DFA到标准输出设备。

  2. 实现原理
    2.1 NFA合并
    (1)创建新的开始状态
    (2)通过ε-转换连接到原NFA的开始状态
    (3)合并状态集、字母表、转移函数和接受状态
    2.2 NFA确定化
    (1)使用子集构造法
    (2)计算ε-闭包
    (3)构造新的状态转移函数
    2.3 DFA最小化
    (1)基于等价类的划分算法
    (2)初始划分为接受状态和非接受状态
    (3)迭代细化状态划分直至稳定

三．软件设计方法的选择

  1. 设计方法
    采用结构化设计方法,主要是考虑到了:
    (1)问题本身具有清晰的数据流向和处理流程
    (2)功能模块划分明确
    (3)算法实现较为直观

  2. 各阶段创建的模型
    2.1 分析阶段：
    (1)系统流程图
    (2)数据流图
    (3)数据字典
    2.2 设计阶段：
    (4)模块结构图
    (5)数据结构设计
    (6)算法流程图

  3. 开发环境
    编程语言: C++11
    编译器: g++
    开发工具: CLion
    依赖库: STL标准模板库

四．分析模型

  1. 系统流程图
    描述：
    开始：实验的起始点，系统准备开始执行。
    读取NFA1与读取NFA2：从输入文件中读取两个非确定有穷自动机（NFA）的描述信息。
    合并NFA：将两个NFA进行合并，创建一个新的NFA，合并后的NFA需要合并状态集、字母表、转移函数等。
    转换为DFA：通过子集构造法将NFA转换为确定性有限自动机（DFA）。
    最小化DFA：对转换后的DFA进行最小化，减少状态数并简化自动机结构。
    输出结果：输出最小化后的DFA描述，显示其状态集、转移函数等信息。
    结束：实验完成。
图2.1 系统流程图

2.数据流图
在这里插入图片描述

图2.2 数据流图

描述：
NFA描述文件：输入文件，包含NFA的定义，如状态集、转移函数、字母表、起始状态和接受状态等。
读取NFA：读取输入文件中的NFA描述并将其转化为程序内部使用的NFA数据结构。
NFA合并：将多个NFA合并为一个新的NFA，该步骤是通过创建一个新的起始状态并加入适当的ε转移来实现的。
NFA转DFA：通过子集构造法将NFA转换成DFA。此过程涉及计算状态的ε-闭包，并构建转移函数。
DFA最小化：对DFA进行最小化处理，使用等价类划分法将DFA的状态集划分为等价类，合并等价状态，减少状态数。
标准输出：输出最小化后的DFA的各项信息，包括状态集、接受状态、转移函数。

3.数据字典
3.1 NFA结构

NFA = {states: 状态集合alphabet: 字母表transitions: 转移函数start_state: 初始状态accept_states: 接受状态集合
}

描述：
states：NFA中的状态集合。
alphabet：NFA的输入字母表，包含所有可能的输入符号。
transitions：转移函数，定义了从一个状态出发，在特定输入下转移到哪些状态（包括ε转移）。
start_state：NFA的起始状态，是计算开始的状态。
accept_states：NFA的接受状态集合，表示能接受输入字符串的状态。

3.2 DFA结构

DFA = {states: 状态集合alphabet: 字母表transitions: 转移函数start_state: 初始状态accept_states: 接受状态集合
}

描述：
states：DFA中的状态集合。
alphabet：DFA的输入字母表，通常与NFA的字母表相同。
transitions：转移函数，定义了在每个状态下，输入符号如何转移到另一个状态。
start_state：DFA的起始状态。
accept_states：DFA的接受状态集合，与NFA的接受状态集合可能不同。

五．设计模型

  1. 模块结构图
    在这里插入图片描述
图2.3 模块结构图

描述：
主程序：程序的核心模块，负责协调其他模块的工作。
文件读取模块：负责从文件中读取NFA的描述，并将其转化为NFA结构。
readNFAFromFile：实现从文件中读取NFA信息，并构造NFA数据结构。
NFA处理模块：负责处理NFA的操作。
mergeNFAs：合并两个NFA，生成一个新的NFA。
getEpsilonClosure：计算NFA状态的ε-闭包。
DFA处理模块：负责将NFA转换为DFA，并对DFA进行最小化。
convertNFAtoDFA：将NFA转换为DFA，使用子集构造法。
minimizeDFA：对DFA进行最小化，减少冗余状态。
输出模块：负责输出最小化后的DFA描述。
printDFA：输出DFA的状态集、接受状态、转移函数等信息。

  1. 主要数据结构
// NFA结构体
struct NFA {set<int> states;                    set<int> alphabet;                  map<pair<int,int>, set<int>> transitions;  int start_state;                    set<int> accept_states;             
};// DFA结构体
struct DFA {set<int> states;                    set<int> alphabet;                  map<pair<int,int>, int> transitions; int start_state;                    set<int> accept_states;             
};

描述：
NFA结构体：定义了NFA的数据结构，其中包括状态集、字母表、转移函数、起始状态和接受状态集。
DFA结构体：定义了DFA的数据结构，类似于NFA，但其转移函数是确定性的，即每个状态对于每个输入符号只有一个确定的转移。

  1. 主要函数接口
    （1）readNFAFromFile：从文件中读取NFA描述，并返回构建好的NFA结构。
    （2）getEpsilonClosure：计算给定状态集的ε-闭包，返回一个新的状态集。
    （3）mergeNFAs：合并两个NFA，返回合并后的NFA。
    （4）convertNFAtoDFA：将给定的NFA转换为DFA。
    （5）minimizeDFA：对给定的DFA进行最小化处理，返回最小化后的DFA。
    （6）printDFA：输出最小化后的DFA的状态集、转移函数、接受状态等。

六．主要算法描述

  1. NFA合并算法
    NFA算法描述：
    寻找最大状态编号：在合并NFA时，首先需要确定新的NFA中的状态编号，应避免与原有NFA中的状态编号冲突。
    创建新起始状态：为合并后的NFA创建一个新的起始状态。
    合并状态集、字母表、转移函数、接受状态：将两个NFA的状态、字母表、转移函数和接受状态集合并成一个新的NFA。
    添加ε转移：通过添加适当的ε转移连接原NFA的起始状态。
图2.4 NFA算法流程图
  1. NFA转化DFA算法
    NFA转化DFA算法描述：
    计算初始状态ε-闭包：使用ε-闭包计算NFA初始状态的所有可达状态。
    初始化DFA：创建一个新的DFA，并将NFA的ε-闭包作为DFA的初始状态。
    判断未处理状态队列空：DFA构造过程中需要遍历所有状态，直到没有状态可处理为止。
    处理所有输入符号：对于当前状态，遍历所有输入符号，计算对应的下一状态。
    更新DFA转移函数：将状态和符号的转移结果添加到DFA的转移函数中。
图2.5 NFA转化DFA算法流程图
  1. DFA最小化算法
    DFA最小化算法描述：
    初始划分：最初将状态划分为接受状态和非接受状态。
    需要继续划分：检查当前划分是否需要进一步细化。若有相同的转移模式的状态，则需要进一步划分。
    对每个划分进行细化：将状态按照它们的转移特征进行细化。
    更新划分映射：更新状态划分的映射关系，确保最小化后的状态集满足等价类划分的要求。
图2.6 DFA最小化算法流程图 ## 七．测试数据与测试效果

  1. 测试数据格式
    输入多个NFA：NFA描述存储在文本文件中，文件名作为命令行参数输入

  2. 测试数据与测试效果
    （1）测试数据1

NFA1：
0 1 2 3 4 5 6 7 8 9 10
0 110
0 -1 1 7
1 -1 2 4
2  0 3
3 -1 6
4  1 5
5 -1 6
6 -1 1 7
7  0 8
8  1 9
9  1 100
10NFA2：
11 12 13 14 15 16 17 18
0 18
11 -1 12 13
12 0 14
13 1 15
14 -1 16
15 -1 16
16 0 17
17 1 1811
18

测试效果：

在这里插入图片描述

图2.7 测试效果1

（2）测试数据2

NFA1：
0 1 2 3 4 5 6 7 8 9 10
0 16
0 -1 1 5
1 -1 2 4
2  0 3
3 -1 4
4  1 5
5 -1 60
6NFA2：
0 1 2 3 4 5 6 7 8 9 10
0 16
0 -1 1 5
1 -1 2 4
2  0 3
3 -1 4
4  1 5
5 -1 60
6

测试效果：

在这里插入图片描述

图2.8 测试效果2

根据实验效果，成功输出合并、最小化以后的DFA到标准输出设备。

八．实验总结

  1. 遇到的问题及解决方法
    （1）ε-闭包计算问题：
    问题：初始实现时未考虑递归计算ε-闭包
    解决：使用队列实现广度优先搜索，确保完整计算闭包
    （2）DFA最小化过程中的等价类划分：
    问题：划分过程中状态映射更新不及时
    解决：每次划分后立即更新状态映射关系
    （3）内存管理问题：
    问题：大规模NFA转换时内存占用过大
    解决：使用STL容器自动管理内存，避免手动内存管理

  2. 收获与体会
    深入理解了自动机理论的实际应用，掌握了复杂算法的工程实现方法，提高了数据结构和算法设计能力，学会了使用STL容器进行高效的数据处理。

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

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

相关文章

【redis进阶】分布式锁

【redis进阶】分布式锁

目录 一、什么是分布式锁 二、分布式锁的基础实现 三、引入过期时间 四、引入校验 id 五、引入lua 六、引入 watch dog (看门狗) 七、引入 Redlock 算法 八、其他功能 redis学习&#x1f973; 一、什么是分布式锁 在一个分布式的系统中&#xff0c;也会涉及到多个节点访问同一…
阅读更多...
Blazor-@bind

Blazor-@bind

数据绑定 带有 value属性的标记都可以使用bind 绑定&#xff0c;<div>、<span>等非输入标记&#xff0c;无法使用bind 指令的&#xff0c;默认绑定了 onchange 事件&#xff0c;onchange 事件是指在输入框中输入内容之后&#xff0c;当失去焦点时执行。 page &qu…
阅读更多...
洛谷P3383 【模板】线性筛素数

洛谷P3383 【模板】线性筛素数

题目链接&#xff1a;P3383 【模板】线性筛素数 - 洛谷 | 计算机科学教育新生态 题目难度&#xff1a;普及一 题目分析&#xff1a;本题是模板题&#xff0c;用到了线性筛法&#xff0c;其中原理是保证范围内的每个合数都被删掉&#xff08;在 bool 数组里面标记为非素数…
阅读更多...
STM32标准库移植RT-Thread nano

STM32标准库移植RT-Thread nano

STM32标准库移植RT-Thread Nano 哔哩哔哩教程链接&#xff1a;STM32F1标准库移植RT_Thread Nano 移植前的准备 stm32标准库的裸机代码&#xff08;最好带有点灯和串口&#xff09;RT-Thread Nano Pack自己的开发板 移植前的说明 本人是在读学生&#xff0c;正在学习阶段&a…
阅读更多...
JVM--类加载器

JVM--类加载器

概念 类加载器&#xff1a;只参与加载过程中的字节码获取并加载到内存中的部分&#xff1b;java虚拟机提供给应用程序去实现获取类和接口字节码数据的一种技术&#xff0c;也就是说java虚拟机是允许程序员写代码去获取字节码信息 类加载是加载的第一步&#xff0c;主要有以下三…
阅读更多...
ECMAScript 6语法

ECMAScript 6语法

1.ES6简介 ECMAScript 6&#xff08;简称ES6&#xff09;是于2015年6月正式发布的JavaScript语言的标准&#xff0c;正式名为ECMAScript 2015&#xff08;ES2015&#xff09;。它的目标是使得JavaScript语言可以用来编写复杂的大型应用程序&#xff0c;成为企业级开发语言 。 …
阅读更多...
联想Y7000+RTX4060+i7+Ubuntu22.04运行DeepSeek开源多模态大模型Janus-Pro-1B+本地部署

联想Y7000+RTX4060+i7+Ubuntu22.04运行DeepSeek开源多模态大模型Janus-Pro-1B+本地部署

直接上手搓了&#xff1a; conda create -n myenv python3.10 -ygit clone https://github.com/deepseek-ai/Janus.gitcd Januspip install -e .pip install webencodings beautifulsoup4 tinycss2pip install -e .[gradio]pip install pexpect>4.3python demo/app_januspr…
阅读更多...
FastAPI + GraphQL + SQLAlchemy 实现博客系统

FastAPI + GraphQL + SQLAlchemy 实现博客系统

本文将详细介绍如何使用 FastAPI、GraphQL&#xff08;Strawberry&#xff09;和 SQLAlchemy 实现一个带有认证功能的博客系统。 技术栈 FastAPI&#xff1a;高性能的 Python Web 框架Strawberry&#xff1a;Python GraphQL 库SQLAlchemy&#xff1a;Python ORM 框架JWT&…
阅读更多...
微服务入门（go）

微服务入门（go）

微服务入门&#xff08;go&#xff09; 和单体服务对比&#xff1a;里面的服务仅仅用于某个特定的业务 一、领域驱动设计&#xff08;DDD&#xff09; 基本概念 领域和子域 领域&#xff1a;有范围的界限&#xff08;边界&#xff09; 子域&#xff1a;划分的小范围 核心域…
阅读更多...
【B站保姆级视频教程：Jetson配置YOLOv11环境（二）SSH连接的三种方式】

【B站保姆级视频教程：Jetson配置YOLOv11环境（二）SSH连接的三种方式】

B站同步视频教程&#xff1a;https://www.bilibili.com/video/BV1m5wUeyEQD/ 在Jetson设备上配置YOLOv11环境时&#xff0c;SSH连接是实现远程高效开发与管理的关键一环。不同的网络环境和硬件配置可能会影响SSH连接的方式&#xff0c;本文将结合相关视频内容&#xff0c;详细…
阅读更多...
计算机毕业设计Python+知识图谱大模型AI医疗问答系统 健康膳食推荐系统 食谱推荐系统 医疗大数据 机器学习 深度学习 人工智能 爬虫 大数据毕业设计

计算机毕业设计Python+知识图谱大模型AI医疗问答系统 健康膳食推荐系统 食谱推荐系统 医疗大数据 机器学习 深度学习 人工智能 爬虫 大数据毕业设计

温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 作者简介&#xff1a;Java领…
阅读更多...
Elasticsearch的索引生命周期管理

Elasticsearch的索引生命周期管理

目录 说明零、参考一、ILM的基本概念二、ILM的实践步骤Elasticsearch ILM策略中的“最小年龄”是如何计算的&#xff1f;如何监控和调整Elasticsearch ILM策略的性能&#xff1f; 1. **监控性能**使用/_cat/thread_pool API基本请求格式请求特定线程池的信息响应内容 2. **调整…
阅读更多...
Vscode的AI插件 —— Cline

Vscode的AI插件 —— Cline

简介 vscode的一款AI辅助吃插件&#xff0c;主要用来辅助创建和编辑文件&#xff0c;探索大型项目&#xff0c;使用浏览器并执行终端命令&#xff08;需要多个tokens&#xff09;&#xff0c;可以使用模型上下文协议&#xff08;MCP&#xff09;来创建新工具并扩展自己(比较慢…
阅读更多...
小白一命速通JS中的windowglobal对象

小白一命速通JS中的windowglobal对象

笔者注意到JS中的window对象与global对象经常被混淆&#xff0c;尽管它们在相当一部分使用情况下可以等同&#xff0c;但是本质上仍然存在很多不同&#xff0c;下面是对于两者的详细拆解 1. window 对象 定义&#xff1a;window 对象表示 浏览器环境中的全局上下文。作用域&am…
阅读更多...
机器学习2 （笔记）（朴素贝叶斯，集成学习，KNN和matlab运用）

机器学习2 （笔记）（朴素贝叶斯，集成学习，KNN和matlab运用）

朴素贝叶斯模型 贝叶斯定理&#xff1a; 常见类型 算法流程 优缺点 集成学习算法 基本原理 常见方法 KNN&#xff08;聚类模型&#xff09; 算法性质&#xff1a; 核心原理&#xff1a; 算法流程 优缺点 matlab中的运用 朴素贝叶斯模型 朴素贝叶斯模型是基于贝叶斯…
阅读更多...
HTB：Active[RE-WriteUP]

HTB：Active[RE-WriteUP]

目录 连接至HTB服务器并启动靶机 信息收集 使用rustscan对靶机TCP端口进行开放扫描 将靶机TCP开放端口号提取并保存 使用nmap对靶机TCP开放端口进行脚本、服务扫描 使用nmap对靶机TCP开放端口进行漏洞、系统扫描 使用nmap对靶机常用UDP端口进行开放扫描 使用nmap对靶机…
阅读更多...
Git图形化工具【lazygit】

Git图形化工具【lazygit】

简要介绍一下偶然发现的Git图形化工具——「lazygit」 概述 Lazygit 是一个用 Go 语言编写的 Git 命令行界面&#xff08;TUI&#xff09;工具&#xff0c;它让 Git 操作变得更加直观和高效。 Github地址&#xff1a;https://github.com/jesseduffield/lazygit 主要特点 主要…
阅读更多...
58.界面参数传递给Command C#例子 WPF例子

58.界面参数传递给Command C#例子 WPF例子

界面参数的传递&#xff0c;界面参数是如何从前台传送到后台的。 param 参数是从界面传递到命令的。这个过程通常涉及以下几个步骤&#xff1a; 数据绑定&#xff1a;界面元素&#xff08;如按钮&#xff09;的 Command 属性绑定到视图模型中的 RelayCommand 实例。同时&#x…
阅读更多...
51单片机（STC89C52）开发：点亮一个小灯

51单片机（STC89C52）开发：点亮一个小灯

软件安装&#xff1a; 安装开发板CH340驱动。 安装KEILC51开发软件&#xff1a;C51V901.exe。 下载软件&#xff1a;PZ-ISP.exe 创建项目&#xff1a; 新建main.c 将main.c加入至项目中&#xff1a; main.c:点亮一个小灯 #include "reg52.h"sbit LED1P2^0; //P2的…
阅读更多...
RoboMaster- RDK X5能量机关实现案例（一）识别

RoboMaster- RDK X5能量机关实现案例（一）识别

作者&#xff1a;SkyXZ CSDN&#xff1a;https://blog.csdn.net/xiongqi123123 博客园&#xff1a;https://www.cnblogs.com/SkyXZ 在RoboMaster的25赛季&#xff0c;我主要负责了能量机关的视觉方案开发&#xff0c;目前整体算法已经搭建完成&#xff0c;实际方案上我使用的上…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023