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.pswp.cn/news/716979.shtml
繁體地址，請注明出處：http://hk.pswp.cn/news/716979.shtml
英文地址，請注明出處：http://en.pswp.cn/news/716979.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

從Poincare猜想看中國數學的國際地位

從Poincare猜想看中國數學的國際地位

2006年丘成桐學派利用北京晨興數學中心&#xff0c;宣布一名俄國學者Poincare猜想研究中存在錯誤&#xff0c;已經由華裔學者朱熹平和曹懷東糾正過來&#xff0c;但數年以后我發現作為千禧七問題之一的Poincazre猜想&#xff0c;英國克萊數學所還是把1百萬美元獎金送給俄國人。…
閱讀更多...
藍橋杯：卡片

藍橋杯：卡片

題目 小藍有很多數字卡片&#xff0c;每張卡片上都是數字0 到9。 小藍準備用這些卡片來拼一些數&#xff0c;他想從1 開始拼出正整數&#xff0c;每拼一個&#xff0c;就保存起來&#xff0c;卡片就不能用來拼其它數了。 小藍想知道自己能從1 拼到多少。 例如&#xff0c;當小…
閱讀更多...
動態規劃-最長公共子串(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. 在每個…
閱讀更多...
Java接口

Java接口

接口的定義 抽象方法的集合&#xff0c;接口通常以interface來聲明。一個類通過繼承接口的方式&#xff0c;從而來繼承接口的抽象方法。 接口并不是類&#xff0c;編寫接口的方式和類很相似&#xff0c;但是他們屬于不同的概念。類描述的是對象的屬性和方法。接口則包含類要實…
閱讀更多...
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…
閱讀更多...
遞歸實現指數型枚舉(c++題解)

遞歸實現指數型枚舉(c++題解)

題目描述 從 1~n 這 n(n<16) 個整數中隨機選取任意多個&#xff0c;輸出所有可能的選擇方案。 輸入格式 一個整數n。 輸出格式 每行一種方案。同一行內的數必須升序排列&#xff0c;相鄰兩個數用恰好1個空格隔開。對于沒有選任何數的方案&#xff0c;輸出空行。 樣例 …
閱讀更多...
python 爬蟲 app爬取之charles的使用

python 爬蟲 app爬取之charles的使用

專欄系列：http://t.csdnimg.cn/WfCSx 前言 前面介紹的都是爬取 Web 網頁的內容。隨著移動互聯網的發展，越來越多的企業并沒有提供 Web 網頁端的服務，而是直接開發了 App，更多更全的信息都是通過 App 來展示的。那么針對 App 我們可以爬取嗎？當然可以。 App 的爬取相比 …
閱讀更多...
使用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是一個函…
閱讀更多...
解決GCC連接器（lld）出現問題 relocation truncated to fit （重定向截斷）

解決GCC連接器（lld）出現問題 relocation truncated to fit （重定向截斷）

本文大致提點這個問題&#xff0c;有哪些可行的解決方案。 這是常見 C/C 的一類連接器錯誤&#xff0c;我們需要知道它一般是怎么產生的&#xff0c;才能知道如何正確的解決它。 例如&#xff1a;&#xff08;當發生這類問題時&#xff0c;連接器通常會輸出這樣的信息&#x…
閱讀更多...
《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;所…
閱讀更多...
最新文章

Copyright @ 2022~2023