20.图

图的基本概念

1.图的定义

由顶点和边组成的集合，G=(V,E)

2.基本概念

邻接点：

对于无向图u v来说，uv互为邻接点
对于有向图u->v来说，v是u的邻接点，但u不是v的临界点

路径：

一个顶点到另一个顶点所经过的顶点构成的序列

有向图：

边是有方向的，单项

无向图：

边是无方向的，双向

有权图：

边有实际意义，也就是权重

无权图：

边无实际意义，无权重，有边置1，无边置0

完全图：

任意两个顶点之间都有两边

连通图：

任意两个顶点之间都有路径

稀疏图：

边远远小于顶点数(n<<m)

稠密图：

边远远大于顶点数(n>>m)

图的存储方式

前言：

图的常见存储方式有
邻接矩阵、邻接表、链式前向星
邻接多重表、十字链表

1.邻接矩阵

<注意>

邻接矩阵的大小至于顶点数有关，为n方，于变数m无关
邻接矩阵的优点是可以在O(1)的时间复杂度下快速找到邻接点，直接g[u] [v]==1?
缺点也很明显，有效边和无效边都存储，太占空间了，适用于稠密图，这样无效边就会变小，不会浪费空间了
遍历n个顶点的邻接点的时间复杂度是O(n^2)

无向无权图

image-20240131222618710 
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
const int N=1e4+10;
//g[i][j]的状态时1/0 1表示ij之间右边 0表示ij之间没边
int g[N][N];//邻接矩阵
int main() {//输入n个顶点，m条边 的无向无权图int n,m;cin>>n>>m;//输入边，初始化邻接矩阵for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}/*   1  2  3  4  5  6  7*1  0  1  1  1  0  0  0*2  1  0  0  0  1  0  0*3  1  0  0  0  0  0  0*4  1  0  0  0  0  1  0*5  0  1  0  0  0  0  0*6  0  0  0  1  0  0  1*7  0  0  0  0  0  1  0* 可以发现矩阵是对称的却其中非零元素个数是2m个* */for(int i=1;i<=n;i++){cout<<i<<"的邻接点为：";for(int j=1;j<=n;j++){if(g[i][j]) cout<<j<<" ";}cout<<endl;}return 0;
}

有向无权图

image-20240131222851848 
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
const int N=1e4+10;
int g[N][N];//邻接矩阵
int main() {//输入n个顶点，m条边 的无向无权图int n,m;cin>>n>>m;//输入边，初始化邻接矩阵for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=1;}/*   1  2  3  4  5  6  7*1  0  1  1  1  0  0  0*2  0  0  0  0  1  0  0*3  0  0  0  0  0  0  0*4  0  0  0  0  0  1  0*5  0  0  0  0  0  0  0*6  0  0  0  0  0  0  0*7  0  0  0  0  0  1  0* 可以发现矩阵是非对称的却其中非零元素个数是m个* */for(int i=1;i<=n;i++){cout<<i<<"的邻接点为：";for(int j=1;j<=n;j++){if(g[i][j]) cout<<j<<" ";}cout<<endl;}return 0;
}

2.邻接表

<注意>

邻接表不会存储无效的边，所以它不会浪费空间
但是它无法直接定位邻接点，邻接矩阵能直接定位邻接点时它申请矩阵的横纵坐标表示的就是顶点的值，直接g[i] [j] 判断是否为1就可以判断j是否是i的邻接点，但是邻接表中的二维vector数组的横纵坐标表示的不是顶点的值，所无法直接定位，而邻接表用的是二维静态vector数组，u顶点的vector[u]数组里面放的都是u的邻接点，不是邻接点不放
因为邻接表采用的是二维静态vector数组，所以它的空间大小也于m边数量无关，至于顶点数n有关

无向无权图

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
const int N=1e4+10;
//二维静态vector数组 邻接表 每个vector[u] 里面都是存的u的邻接点
vector<int> g[N];int main() {//输入n个顶点，m条边 的无向无权图int n,m;cin>>n>>m;//输入边，初始化邻接矩阵for(int i=1;i<=m;i++){int u,v;cin>>u>>v;//无向图 邻接表g[u].push_back(v);g[v].push_back(u);}/** vector<int> g[1]    2 3 4* vector<int> g[2]    1* vector<int> g[3]    1* vector<int> g[4]    1 6* vector<int> g[5]    2* vector<int> g[6]    4 7* vector<int> g[7]    6* */for(int i=1;i<=n;i++){cout<<i<<"的邻接点为：";for(int j=0;j<g[i].size();j++){//邻接表里面存的就是邻接点cout<<g[i][j]<<" ";}cout<<endl;}return 0;
}

有向无权图

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
const int N=1e4+10;
//二维静态vector数组 邻接表 每个vector[u] 里面都是存的u的邻接点
vector<int> g[N];int main() {//输入n个顶点，m条边 的无向无权图int n,m;cin>>n>>m;//输入边，初始化邻接矩阵for(int i=1;i<=m;i++){int u,v;cin>>u>>v;//有向图 邻接表g[u].push_back(v);;}/** vector<int> g[1]    2 3 4* vector<int> g[2]    1* vector<int> g[3]    1* vector<int> g[4]    1 6* vector<int> g[5]    2* vector<int> g[6]    4 7* vector<int> g[7]    6* */for(int i=1;i<=n;i++){cout<<i<<"的邻接点为：";for(int j=0;j<g[i].size();j++){//邻接表里面存的就是邻接点cout<<g[i][j]<<" ";}cout<<endl;}return 0;
}

总结：

邻接矩阵中，行列坐标表示顶点，数组值表示是否存在邻接点
邻接表中，行坐标表示顶点，行坐标的vector数组中存储的是它的邻接点

图论算法

DFS

1.DFS（栈）

DFS就是沿着一条路走到黑，知道路没有了再回头，栈可以后进先搜
用邻接矩阵实现

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
const int N=1e4+10;
int g[N][N],n,m;
//标记数组，用来标记已经入栈过的顶点
bool vis[N];
void DFS(int s){stack<int> stk;//起始点入栈，入栈就标记stk.push(s);vis[s]=true;while(!stk.empty()){int cur=stk.top();stk.pop();cout<<cur<<"  ";//把栈顶顶点所有的邻接点入栈//邻接矩阵for(int i=1;i<=n;i++){//入栈过的就不能再搜了if(!vis[i]&&g[cur][i]) stk.push(i),vis[i]=true;}//邻接表for(int i=0;i<g[cur].size();i++){//入栈过的就不能再搜了if(!vis[i]) stk.push(g[cur][i]),vis[g[cur][i]]=ture;}}
}
int main() {cin>>n>>m;int s;cin>>s;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}DFS(s);return 0;
}
入栈就标记，出栈就搜邻接点，没被搜过的入栈

2.DFS(递归)

递归分为两部分，搜索部分和回溯部分

#include <iostream>using namespace std;
const int N=1e4+10;
int n,m,g[N][N];
bool vis[N];
//dfs(int status)状态，s为搜索状态
void dfs(int s){//正在搜索s//正在搜索的先输出cout<<s<<"  ";//找当前搜索状态的邻接点for(int i=1;i<=n;i++){if(g[s][i]&&!vis[i]){vis[i]=1;dfs(i);}}
}
/** cout<<1 2 3 5 7 6 8 4* vis 1 3 5 6 8 4* 1.DFS(1)   cout<<1     i=2 vis[2]=1    DFS(2)  i=7 vis[7]=1 DFS(7)   i=8 vis[8]=1    DFS(8)X* 2.DFS(8)   cout<<8     i=4 vis[4]=1    DFS(4)X* 3.DFS(4)   cout<<4     X* 2.DFS(7)   cout<<7     i=6 vis[6]=1    DFS(6)X* 3.DFS(6)   cout<<6     X* 2.DFS(2)   cout<<2     i=3 vis[3]=1    DFS(3)X* 3.DFS(3)   cout<<3     i=5 vis[5]=1    DFS(5)X* 4.DFS(5)   cout<<5     X* */
int main(){cin>>n>>m;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}int s;cin>>s;//启动dfs前要把初始状态标记vis[s]=1;dfs(s);//搜索的初始状态return 0;
}

3.连通块问题(求连通块数量)

循环深搜

#include <iostream>using namespace std;
const int N=1e4+10;
int n,m,g[N][N];
bool vis[N];
//dfs(int status)状态，s为搜索状态
void dfs(int s){//正在搜索sfor(int i=1;i<=n;i++){if(g[s][i]&&!vis[i]){vis[i]=1;dfs(i);}}
}
int main(){int cnt=0;cin>>n>>m;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}//循环深搜for(int i=1;i<=n;i++){//只要没被标记就深搜if(!vis[i]){vis[i]=true;dfs(i);//深搜一次就cnt++cnt++;}}cout<<cnt<<endl;return 0;
}

4.DFS求无权图最短路径长度

#include <iostream>using namespace std;
const int N=1e4+10;
int n,m,s,t,ans=0,g[N][N];
bool vis[N];
//dfs(int status)状态，s为搜索状态
void dfs(int s,int depth){if(s==t){ans=min(ans,depth-1);return;}for(int i=1;i<=n;i++){if(g[s][i]&&!vis[i]){vis[i]=1;dfs(i,depth+1);//回溯阶段把标记取消，这样可以多次在不同路径找到终点，从而找到最短路径vis[i]=0;}}
}
/*  vis 1* s=1 t=4* 1.dfs(1) ans=0   i=1 vis[1]=1    dfs(2)  vis[2]=0 i=5 vis[5]=1 dfs(5) vis[5]=0 X* 2.dfs(5) ans=0   i=4 vis[4]=1    dfs(4)  vis[4]=0 X* 3.dfs(4) ans=2 X* 2.dfs(2) ans=0   i=3 vis[3]=1    dfs(3)  vis[3]=0 X* 3.dfs(3) ans=0   i=4 vis[4]=1    dfs(4)  vis[4]=0 X* 4.dfs(4) ans=3 X* cout<<ans=2* */
int main(){int cnt=0;cin>>n>>m;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}cin>>s>>t;//最短路径的起点和终点vis[s]=true;dfs(s,1);cout<<ans<<endl;return 0;
}

dfs解决最短路问题时间复杂度：O(2^n)

组合问题时间复杂度为：O(2^n)，n最多为25，算法不会超时
排列问题时间复杂度为：O(n!)，n最多为11，算法不会超时
不会产生排列情况

5.DFS求无权图最短路径

image-20240202151127057 image-20240202151146920 
#include <iostream>
#include <vector>
using namespace std;
const int N=128;
vector<char> path,res;
char s,t;
bool vis[N];
int m,ans=0x3f3f3f3f,g[N][N],k;
void dfs(char s,int depth){if(s==t) {if(ans>depth-1){ans=depth-1;res=path;}return ;}for(char c='A';c<='Z';c++){if(!vis[c]&&g[s][c]){vis[c]=true;path.push_back(c);dfs(c,depth+1);path.pop_back();vis[c]=false;}}
}
/** vis A* path A* res A E F* 1.dfs(A) c=B    vis[B]=1   push B    dfs(B) c=E vis[E]=1 push E dfs(E) c=F vis[F]=1 push F dfs(F)* 2.dfs(F) ans=2 res X* 2.dfs(E) c=D    vis[D]=1   push D    dfs(D) X* 3.dfs(D) c=C    vis[C]=1   push C    dfs(C) X* 4.dfs(C) c=B    vis[B]=1   push B    dfs(B) X* 5.dfs(B) X* 2.dfs(B) c=C    vis[C]=1   push C    dfs(C) X* 3.dfs(C) c=D    vis[D]=1   push D    dfs(D) X* 4.dfs(D) c=E    vis[E]=1   push E    dfs(E)  pop c=F     vis[F]=1    push F dfs(F) pop X* 5.dfs(F) ans=4 res X* 5.dfs(E) c=F    vis[F]=1   push F    dfs(F)  pop X* 6.dfs(F) ans=5 res X* */int main(){cin>>m;for(int i=1;i<=m;i++){char u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}cin>>s>>t;vis[s]=true;path.push_back(s);dfs(s,1);cout<<"最短路长度为"<<ans<<endl;cout<<"最短路径为：";for(int i=0;i<res.size()-1;i++){printf("%c->",res[i]);}printf("%c",res[res.size()-1]);return 0;
}

BFS

1.BFS输出图中元素

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1e4+10;
int g[N][N],n,m,st;
bool vis[N];
//input:
//1 2
//2 3
//3 4
//1 9
//9 5
//5 6
//6 7
//7 4
//1 8
//8 6
//1
//output:
//1 2 8 9 3 6 5 4 7
void bfs(int s){queue<int> q;q.push(s);vis[s]=1;while(!q.empty()){int cur=q.front();cout<<cur<<" ";q.pop();for(int i=1;i<=n;i++){if(!vis[i]&&g[cur][i]){q.push(i);vis[i]=1;}}}
}
int main(){cin>>n>>m;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}cin>>st;bfs(st);return 0;
}

2.BFS解决连通块问题

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1e4+10;
int g[N][N],n,m,cnt;
bool vis[N];
//input:
//8 5
//
//1 2
//2 3
//4 5
//6 7
//6 8
//
//ouput:
//3
void bfs(int s){queue<int> q;q.push(s);while(!q.empty()){int cur=q.front();q.pop();for(int i=1;i<=n;i++){if(!vis[i]&&g[cur][i]){q.push(i);vis[i]=1;}}}
}
int main(){cin>>n>>m;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}for(int i=1;i<=n;i++){if(!vis[i]){vis[i]=1;bfs(i);cnt++;}}cout<<cnt<<endl;return 0;
}

3.BFS求最短路

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=1e4+10;
struct node{int id,depth;
};
int g[N][N],n,m,st,t,ans;
int pre[N];
bool vis[N];
//9 10
//
//1 2
//2 3
//3 4
//1 9
//9 5
//5 6
//6 7
//7 4
//1 8
//8 6
//
//1 7
//ouput:
//3
//1 8 6 7//bfs求最短路的时间复杂度是O(n+m)
void bfs(node s){//由于bfs不是递归，无法将层数和搜索状态绑定，只能使用结构体将搜索状态和层数绑定queue<node> q;q.push(s);vis[s.id]=1;while(!q.empty()){node cur=q.front();q.pop();if(cur.id==t){ans=cur.depth-1;return ;}for(int i=1;i<=n;i++){if(!vis[i]&&g[cur.id][i]){q.push({i,cur.depth+1});pre[i]=cur.id;vis[i]=1;}}}
}
void getpath(int s){if(!s) return ;getpath(pre[s]);cout<<s<<" ";
}
//1.g(7) g(6) 7
//2.g(6) g(8) 6
//3.g(8) g(1) 8
//4.g(1) g(0) 1
//5.g(0) X
int main(){cin>>n>>m;for(int i=1;i<=m;i++){int u,v;cin>>u>>v;g[u][v]=g[v][u]=1;}cin>>st>>t;bfs({st,1});cout<<ans<<endl;getpath(t);return 0;
}

4.迷宫问题

DFS解决-能否走出迷宫

#include <iostream>using namespace std;
const int N=1e4+10;
int n,m,sx,sy,tx,ty;
char g[N][N];//二维迷宫
bool vis[N][N],flag;
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
//8 8
//*****...
//*.S...**
//*****.**
//*****..*
//*T..**.*
//.**.**.*
//..*....*
//...*****//YES
void dfs(int px,int py){if(px==tx&&py==ty){//当前状态为终点flag=true;return ;}//向着邻接点DFSfor(int i=0;i<4;i++){int bx=px+dx[i],by=py+dy[i];//合法性判断if(bx<1||bx>n||by<1||by>m||g[bx][by]=='*'||vis[bx][by]) continue;vis[bx][by]=1;dfs(bx,by);}
}
int main(){cin>>n>>m;for(int i=1;i<=n;i++){for(int j=1;j<=n;j++){cin>>g[i][j];if(g[i][j]=='S') sx=i,sy=j;else if(g[i][j]=='T') tx=i,ty=j;}}vis[sx][sy]=1;dfs(sx,sy);if(flag){cout<<"YES"<<endl;}elsecout<<"NO"<<endl;return 0;
}

BFS解决-能否走出迷宫

#include <iostream>
#include <queue>
#include<Windows.h>
using namespace std;
const int N=1e4+10;
int n,m,sx,sy,tx,ty;
char g[N][N];//二维迷宫
bool vis[N][N],flag;
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
struct node{int x,y,depth;
};
//8 8
//*****...
//*.S...**
//*****.**
//*****..*
//*T..**.*
//.**.**.*
//..*....*
//...*****//YES
void bfs(node s){queue<node> q;q.push(s);vis[s.x][s.y]=1;while(!q.empty()){node cur=q.front();q.pop();//当前搜索状态if(cur.x==tx&&cur.y==ty){flag=true;cout<<cur.depth-1<<endl;return;}for(int i=0;i<4;i++){int bx=cur.x+dx[i],by=cur.y+dy[i];if(bx<1||bx>n||by<1||by>m||g[bx][by]=='*'||vis[bx][by]) continue;vis[bx][by]=1;q.push({bx,by,cur.depth+1});}}
}
int main(){cin>>n>>m;for(int i=1;i<=n;i++){for(int j=1;j<=m;j++){cin>>g[i][j];if(g[i][j]=='S') sx=i,sy=j;else if(g[i][j]=='T') tx=i,ty=j;}}bfs({sx,sy,1});if(flag){cout<<"YES"<<endl;}elsecout<<"NO"<<endl;return 0;
}

找没被标记过的邻接点，入栈即标记

找没被标记过的邻接点，深搜即标记

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

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

相关文章

动态规划-最长公共子串(c)

动态规划-最长公共子串(c)

动态规划 动态规划&#xff08;dynamic programming&#xff09;是一种算法设计方法。基本思想是在对一个问题的多阶段决策中&#xff0c;按照某一顺序&#xff0c;根据每一步所选决策的不同&#xff0c;会引起状态的转移&#xff0c;最后会在变化的状态中获取到一个决策序列。…
阅读更多...
vs code更新后json文件无法识别通配符 ，编译多文件失败的解决办法

vs code更新后json文件无法识别通配符 ，编译多文件失败的解决办法

问题描述 在Mac或者LInux上&#xff0c;进行C/C相同路径下进行多文件编译时&#xff0c;之前设置好的json文件突然不能解释通配符&#xff0c;并且将带有单引号的地址传给clang&#xff0c;由于*.c被扩在单引号中&#xff0c;clang找不到文件导致失败。 如果将命令端中的指令复…
阅读更多...
云服务器无法Ping通解决

云服务器无法Ping通解决

问题: 使用公网IP地址PING云服务器,无法PING通 但是可SSH到服务器,表示通信链路是正常的,可能是端口或路径规则未开放导致 登陆云服务器后台,进行安全组规则查看,发现ICMP没有放行 添加允许ICMP连接规则 成功PING通云服务器
阅读更多...
LeetCode——二叉树（Java）

LeetCode——二叉树（Java）

二叉树 简介[简单] 144. 二叉树的前序遍历、94. 二叉树的中序遍历、145. 二叉树的后序遍历二叉树层序遍历[中等] 102. 二叉树的层序遍历[中等] 107. 二叉树的层序遍历 II[中等] 199. 二叉树的右视图[简单] 637. 二叉树的层平均值[中等] 429. N 叉树的层序遍历[中等] 515. 在每个…
阅读更多...
AcWing 4726. 寻找数字

AcWing 4726. 寻找数字

解题思路 在这个二插搜索树中寻找&#xff0c;4和7数量相等&#xff0c;并且大于n的最小数。 相关代码 import java.util.*;public class Main {static String s;static List<Integer> res new ArrayList<>();static long n;static long ansLong.MAX_VALUE;publ…
阅读更多...
使用HTML5画布（Canvas）模拟图层（Layers）效果

使用HTML5画布（Canvas）模拟图层（Layers）效果

使用HTML5画布&#xff08;Canvas&#xff09;模拟图层&#xff08;Layers&#xff09;效果 在图形处理和计算机图形学中&#xff0c;图层&#xff08;Layers&#xff09;是指将图像分成不同的可独立编辑、组合和控制的部分的技术或概念。每个图层都可以包含不同的图形元素、效…
阅读更多...
18.题目：编号760 数的计算

18.题目：编号760 数的计算

题目&#xff1a; ###该题主要考察递推、递归 将该题看成若干个子问题 #include<bits/stdc.h> using namespace std; const int N20; int a[N];int dfs(int dep){int res1;for(int i1;i<a[dep-1]/2;i){a[dep]i;resdfs(dep1);}return res; }int main(){int n;cin>…
阅读更多...
python并发 map函数的妙用

python并发 map函数的妙用

1.map是什么&#xff1f; map函数是Python中的一个内置函数&#xff0c;用于将一个函数应用到一个或多个可迭代对象的每个元素上&#xff0c;生成一个新的可迭代对象。它的一般形式是&#xff1a; map(function, iterable1, iterable2, ...)其中&#xff0c;function是一个函…
阅读更多...
《Spring Security 简易速速上手小册》第8章 常见问题与解决方案（2024 最新版）

《Spring Security 简易速速上手小册》第8章 常见问题与解决方案（2024 最新版）

文章目录 8.1 异常处理和日志记录8.1.1 基础知识详解8.1.2 重点案例&#xff1a;统一异常处理案例 Demo拓展 8.1.3 拓展案例 1&#xff1a;日志记录策略案例 Demo拓展 8.1.4 拓展案例 2&#xff1a;日志聚合案例 Demo拓展 8.2 多租户安全性问题8.2.1 基础知识详解8.2.2 重点案例…
阅读更多...
深入Kafka client

深入Kafka client

分区分配策略 客户端可以自定义分区分配策略, 当然也需要考虑分区消费之后的offset提交, 是否有冲突。 消费者协调器和组协调器 a. 消费者的不同分区策略, 消费者之间的负载均衡(新消费者加入或者存量消费者退出), 需要broker做必要的协调。 b. Kafka按照消费组管理消费者, …
阅读更多...
VUE3:省市区联级选择器

VUE3:省市区联级选择器

一、实现效果 二、代码展示 <template><div class"page"><select v-model"property.province"><option v-for"item in provinces" :key"item">{{ item }}</option></select><select v-model&…
阅读更多...
今日学习总结2024.3.2

今日学习总结2024.3.2

最近的学习状态比较好&#xff0c;感觉非常享受知识进入脑子的过程&#xff0c;有点上头。 实验室一个星期唯一一天的假期周六&#xff0c;也就是今天&#xff0c;也完全不想放假出去玩啊&#xff0c;在实验室泡了一天。 很后悔之前胆小&#xff0c;没有提前投简历找实习&…
阅读更多...
YOLOv9有效提点|加入MobileViT 、SK 、Double Attention Networks、CoTAttention等几十种注意力机制（五）

YOLOv9有效提点|加入MobileViT 、SK 、Double Attention Networks、CoTAttention等几十种注意力机制（五）

专栏介绍&#xff1a;YOLOv9改进系列 | 包含深度学习最新创新&#xff0c;主力高效涨点&#xff01;&#xff01;&#xff01; 一、本文介绍 本文只有代码及注意力模块简介&#xff0c;YOLOv9中的添加教程&#xff1a;可以看这篇文章。 YOLOv9有效提点|加入SE、CBAM、ECA、SimA…
阅读更多...
ETH网络中的区块链

ETH网络中的区块链

回顾BTC网络的区块链系统 什么是区块链&#xff1f;BTC网络是如何运行的&#xff1f;BTC交易模式 - UXTO ETH网络中的区块链 ETH网络的基石依旧是 区块链。上面 什么是区块链&#xff1f; 的文章依旧适用。 相比BTC网络&#xff0c;ETH网络的账户系统就相对复杂&#xff0c;所…
阅读更多...
实用工具：实时监控服务器CPU负载状态并邮件通知并启用开机自启

实用工具：实时监控服务器CPU负载状态并邮件通知并启用开机自启

作用&#xff1a;在服务器CPU高负载时发送邮件通知 目录 一、功能代码 二、配置开机自启动该监控脚本 1&#xff0c;配置自启脚本 2&#xff0c;启动 三、功能测试 一、功能代码 功能&#xff1a;在CPU负载超过预设置的90%阈值时就发送邮件通知&#xff01;邮件内容显示…
阅读更多...
js中Generator函数详解

js中Generator函数详解

定义&#xff1a; promise是为了解决回调地狱的难题出现的&#xff0c;那么 Generator 就是为了解决异步问题而出现的。 普通函数&#xff0c;如果调用它会立即执行完毕&#xff1b;Generator 函数&#xff0c;它可以暂停&#xff0c;不一定马上把函数体中的所有代码执行完毕…
阅读更多...
Linux基本指令（下）

Linux基本指令（下）

目录 1. less指令 2. head与tail指令 3. find指令 示例 4. grep指令 示例 ​编辑 5. zip/unzip 打包与压缩 示例 ​编辑 6. tar指令 7. find指令&#xff1a; -name 8. echo指令 9. 时间相关的指令 1.在显示方面&#xff0c;使用者可以设定欲显示的格式&#xff…
阅读更多...
【机器学习】有监督学习算法之：K最近邻

【机器学习】有监督学习算法之：K最近邻

K最近邻 1、引言2、决策树2.1 定义2.2 原理2.3 实现方式2.3.1 距离度量2.3.2 K值的选择 2.4 算法公式2.5 代码示例 3、总结 1、引言 小屌丝&#xff1a;鱼哥&#xff0c; 这么长时间没更新了&#xff0c;是不是得抓紧时间了。 小鱼&#xff1a;最近可都是在忙的呢&#xff0c;…
阅读更多...
线上历史馆藏系统 Java+SpringBoot+Vue+MySQL

线上历史馆藏系统 Java+SpringBoot+Vue+MySQL

✍✍计算机编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java实战 |…
阅读更多...
day09_商品管理订单管理SpringTaskEcharts

day09_商品管理订单管理SpringTaskEcharts

文章目录 1 商品管理1.1 添加功能1.1.1 需求说明1.1.2 核心概念SPUSKU 1.1.3 加载品牌数据CategoryBrandControllerCategoryBrandServiceCategoryBrandMapperCategoryBrandMapper.xml 1.1.4 加载商品单元数据ProductUnitProductUnitControllerProductUnitServiceProductUnitMap…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023