图算法
DFS:
const int MAXV=1000;
const int INF=10000000000000;
1.邻接矩阵版
int n,G[MAXV][MAXV];
bool vis[MAXV]={false};
void DFS(int u,int depth){
vis[u]=true;
for(int v=0;v<n;;v++){
if(vis[v]==false&&G[u][v]!=INF){
DFS(v,depth+1);
}
}
}
void DFSTrave(){
for(int u=0;u<n;u++){
if(vis[u]==false){
DFS(u,1);
}
}
}
2.邻接表版
vector<int> Adj[MAXV];
int n;
bool vis[MAXV]={false}; oid DFS(int u,int depth){
vis[u]=true;
for(int i=0;i<Adj[u].size;u++){
int v=Adj[u][i];
if(vis[v]==false){
DFS(v,depth+1);
}
}
}
void DFSTrave(){
for(int u=0;u<n;u++){
if(vis[u]==false){
DFS(u,1);
}
}
}
BFS
1.邻接矩阵版
int n,G[MAXV][MAXV];
bool inq[MAXV]={false};
void BFS(int u){
queue<int> q;
q.push(u);
inq[u]=true;
while(!q.empty()){
int u=q.front();
q.pop();
for(int v=0;v<n;v++){
if(inq[v]==false&&G[u][v]!=INF){
q.push(v);
inq[v]=true;
}
}
}
}
void BFSTrave(){
for(int u=0;u<n;u++){
if(inq[u]==false){
BFS(q);
}
}
}
2.邻接表版
vector<int> Adj[MAXV];
int n;
bool inq[MAXV]={false};
void BFS(int u){
queue<int> q;
q.push(u);
inq[u]=false;
while(!q.empty()){
int u=q.front();
q.pop();
for(int i=0;i<Adj[u].size();i++){
int v=Adj[u][i];
if(inq[v]==false){
q.push(v);
inq[v]=true;
}
}
}
}
void BFSTrave(){
for(int u=0;u<n;u++){
if(inq[u]==false){
BFS(q);
}
}
}
Dijkstra:
const int MAXV=1000;
const int INF=1000000000000;
1.邻接矩阵版
int n,G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV]={false};
void Dijkstra(int s){
fill(d,d+MAXV,INF);
d[s]=0;
for(int i=0;i<n;i++){
int u=1,MIN=INF;
for(int j=0;j<n;j++){
if(vis[j]==false&&d[j]<MIN){
u=j;
MIN=d[j];
}
}
if(u==-1)return;
vis[u]=true;
for(int v=0;v<n;v++){
if(vis[v]==false&&G[u][v]!=INF&&d[u]+G[u][v]<d[v]){
d[v]=d[u]+G[u][v];
}
}
}
}
2.邻接表版
struct Node{
int v,dis;
};
vector<Node> Adj[MAXV];
for(int j=0;j<Adj[u].size();j++){
int v= Adj[u][j].v;
if(vis[v]==false&&d[u]+Adj[u][j]<d[v]){
d[v]=d[u]+Adj[u][j];
}
}
Bellman-Ford(无负权图的最短路径问题)
struct Node{
int v,dis;
};
vector<int> Adj[MAXV];
int n;
int d[MAXV];
bool Bellman(int s){
fill(d,d+MAXV,INF);
d[s]=0;
for(int i=0;i<n-1;i++){
for(int u=0;u<n;u++){
for(int j=0;j<Adj[u].size();j++){
int v=Adj[u][j].v;
int dis=Adj[u][j].dis;
if(d[u]+dis>d[v]){
d[v]=d[u]+dis;
}
}
}
}
for(int u=0;u<n;u++){
for(int j=0;j<Adj[u].size();j++){
int v=Adj[u][j].v;
int dis=Adj[u][j].dis;
if(d[u]+dis<d[v]){
return false;
}
}
}
return true;
}
Floyd算法(全源最短路问题)
void Floyd(){
for(int k=0;k<n;k++){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(dis[i][k]!=INF&&dis[k][j]!=INF&&dis[i][k]+dis[k][j]<dis[i][j]){
dis[i][j]=dis[i][k]+dis[k][j];
}
}
}
}
}
最小生成树
Prim
const int MAXV=1000;
const int INF=10000000000;
1.邻接矩阵
int n,G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV]={false};
int prim(){
fill(d,d+MAXV,INF);
d[0]=0;
int ans=0;
for(int i=0;i<n;i++){
int u=-1,MIN=INF:
for(int j=0;j<n;j++){
if(vis[j]==false&&d[j]<MIN){
u=j;
MIN=d[j];
}
}
if(u==-1)return -1;
vis[u]=true;
ans+=d[u];
for(int v=0;v<n;v++){
if(vis[v]==false&&G[u][v]!=INF&&G[u][v]<d[v]){
d[v]=G[u][v];
}
}
}
return ans;
}
2.邻接表
struct Node{
int v,dis;
};
vector<Node> Adj[MAXV];
int n;
int d[MAXV];
bool vis[MAXV]={false};
int prim(){
ffill(d,d+MAXV,INF);
d[0]=0;
int ans=0;
for(int i=0;i<n;i++){
int u=-1,MIN=INF;
for(int j=0;j<n;j++){
if(vis[j]==false&&d[j]<MIN){
u=j;
MIN=d[j];
}
}
}
if(u==-1)return -1;
vis[u]=true;
ans+=d[u];
for(int j=0;j<Adj[u].size();j++){
int v=Adj[u][j].v;
if(vis[v]==false&&Adj[u][j].dis<d[v]){
d[v]=Adj[u][j].dis;
}
}
return ans;
}
拓扑排序
vector<int> G[MAXV];
int n,m,inDegree[MAXV];
bool tp(){
int num=0;
queue<int> q;
for(int i=0;i<n;i++){
if(inDegree[i]==0){
q.push(i);
}
}
while(!q.empty()){
int u=q.front();
q.pop();
for(int i=0;i<G[u].size();i++){
int v=G[u][i];
inDegree[v]--;
if(inDegree[v]==0){
q.push(v);
}
}
G[u].clear();
num++;
}
if(num++n)return true;
else return false;
}
动态规划
数塔:
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++)
scanf("%d",&f[i][j]);
}
for(int j=1;j<=n;j++){
dp[n][j]=f[n][j];
}
for(int i=n-1;i>=1;i--){
for(int j=1;j<=i;j++){
dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+f[i][j];
}
}
并查集
int father[N];
1.初始化
for(int i=1;i<=N;i++){
father[i]=i;
}
2.查找
int findFather(int x){
while(x!=father[x]){
x=father[x];
}
return x;
}
3.合并
void Union(int a,int b){
int faA=findFather(a);
int faB=findFather(b);
if(faA!=fbB){
father[faA]=faB;
}
}
4.路径压缩
int findFather(int x){
int a=x;
while(x!=father[x]){
x=father[x];
}
while(a!=father[a]){
int z=a;
a=father[a];
father[z]=x;
}
return x;
}