DFS
全排列问题
#include<bits/stdc++.h>
using namespace std;
const int N=10;
int n;
int path[N];
bool st[N];
void dfs(int x)
{
if(x>n)
{
for(int i=1;i<=n;i++) cout<<path[i]<<" ";
cout<<endl;
return ;
}
for(int i=1;i<=n;i++)
{
if(!st[i])
{
path[x]=i;
st[i]=true;
dfs(x+1);
st[i]=false;
}
}
}
signed main()
{
cin>>n;
dfs(1);
return 0;
}n-皇后问题
题目要求同一行、同一列、同一斜线上只能有一个皇后。
我们开3个数组记录列、斜线、反斜线是否有皇后存在。
用dfs把每一行都走一遍，同时遍历列，
对每一个点，考察它的列、斜线、反斜线上是否有别的皇后，（因为行是在dfs的参数里考察的，有唯一性）
如果没有就放皇后并且标记为true
#include<bits/stdc++.h>
using namespace std;
const int N=10;
int n;
bool row[N],col[N],dg[N*2],udg[N*2];//列行正对角线
char g[N][N];
void dfs(int x)//遍历行
{
if(x==n)
{
for(int i=0;i<n;i++) puts(g[i]);
puts("");
return;
}
for(int i=0;i<n;i++)//遍历列
{
if(!row[i]&&!dg[i-x+n]&&!udg[x+i])
{
g[x][i]='Q';
row[i]=dg[i-x+n]=udg[x+i]=true;
dfs(x+1);
g[x][i]='.';
row[i]=dg[i-x+n]=udg[x+i]=false;
}
}
}
signed main()
{
cin>>n;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
g[i][j]='.';
dfs(0);
return 0;
}BFS
走迷宫
#include<bits/stdc++.h>
using namespace std;
const int N=110;
typedef pair<int,int> PII;
int g[N][N],dist[N][N];
int n,m;
PII q[N*N];
int hh=0,tt=-1;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int bfs(int x,int y)
{
memset(dist,-1,sizeof dist);
dist[x][y]=0;
q[++tt]={x,y};
while(hh<=tt)
{
PII t=q[hh++];
for(int i=0;i<4;i++)
{
int a=t.first+dx[i];
int b=t.second+dy[i];
if(dist[a][b]!=-1) continue;
if(g[a][b]!=0) continue;
if(a<1||b<1||a>n||b>m) continue;
q[++tt]={a,b};
dist[a][b]=dist[t.first][t.second]+1;
if(a==n&&b==m) return dist[a][b];
}
}
}
signed main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>g[i][j];
}
}
int res=bfs(1,1);
cout<<res;
return 0;
}八数码
思路： 设置开始和最后的状态，存在一个字符串里面。如“12345678x”
用bfs，每回找到队列里的x做变换，用dis记录步数
最后队头的string==end，就说明存在解决方案，输出即可
否则返回-1。
#include<bits/stdc++.h>
using namespace std;
queue<string> q;
unordered_map<string,int> d;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int bfs(string start)
{
q.push(start);
d[start]=0;
string end="12345678x";
while(!q.empty())
{
auto t=q.front();
q.pop();
if(t==end) return d[t];
int distance=d[t];
int k=t.find('x');
int x=k/3,y=k%3;
for(int i=0;i<4;i++)
{
int a=dx[i]+x,b=dy[i]+y;
if(a>=0&&a<3&&b>=0&&b<3)
{
swap(t[k],t[a*3+b]);
if(!d.count(t))
{
d[t]=distance+1;
q.push(t);
}
swap(t[k],t[a*3+b]);
}
}
}
return -1;
}
signed main()
{
string start;
for(int i=0;i<9;i++)
{
char pp;
cin>>pp;
start+=pp;
}
cout<<bfs(start)<<endl;
return 0;
}树与图的深度优先遍历
树的重心
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10,M=2*N;
int n;
int e[M],h[N],ne[M],idx;
int ans=N;
bool st[N];
void add(int a,int b)
{
e[idx]=b;
ne[idx]=h[a];
h[a]=idx++;
}
int dfs(int u)
{
st[u]=true;
int sum=0,size=0;
for(int i=h[u];i!=-1;i=ne[i])
{
int j=e[i];
if(st[j]) continue;
int s=dfs(j);
sum+=s;//作为当前这个根的结点数
size=max(size,s);//剩余各个连通块中点数的最大值
}
size=max(size,n-sum-1);//剩余的点自己组成一个连通块
ans=min(ans,size);//结果是最小的最大值
return sum+1;//要记得包含自己这个结点
}
signed main()
{
cin>>n;
memset(h,-1,sizeof h);
for(int i=1;i<n;i++)
{
int a,b;
cin>>a>>b;
add(a,b);
add(b,a);
}
dfs(1);
cout<<ans;
return 0;
} 树与图的广度优先遍历
图中点的层次
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int h[N],e[N],ne[N],idx;
int n,m;
int hh=0,tt=-1;
int q[N],d[N];
void add(int a,int b)
{
e[idx]=b;
ne[idx]=h[a];
h[a]=idx++;
}
int bfs()
{
memset(d,-1,sizeof d);
q[++tt]=1;
d[1]=0;
while(hh<=tt)
{
auto t=q[hh++];
for(int i=h[t];i!=-1;i=ne[i])
{
int j=e[i];
if(d[j]!=-1) continue;
q[++tt]=j;
d[j]=d[t]+1;
}
}
return d[n];
}
signed main()
{
memset(h,-1,sizeof h);
cin>>n>>m;
while(m--)
{
int a,b;
cin>>a>>b;
add(a,b);
}
cout<<bfs()<<endl;
return 0;
}拓扑排序
有向图的拓扑序列
啥是拓扑排序?
一个有向图，如果图中有入度为 0 的点，就把这个点删掉，同时也删掉这个点所连的边。
一直进行上面出处理，如果所有点都能被删掉，则这个图可以进行拓扑排序。
思路：突破口是入度为0 的点
把已知的入度为0的点放进队列
只要队列不空，取出队头->t
枚举t的所有出边t->j
删掉t->j j的入度--
if（j的入度为0） 让j入队
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n,m;
int h[N],e[N],ne[N],idx;
int q[N],d[N];
int hh,tt=-1;
void add(int a,int b)
{
e[idx]=b;
ne[idx]=h[a];
h[a]=idx++;
}
void topsort()
{
for(int i=1;i<=n;i++)
{
if(!d[i]) q[++tt]=i;
}
while(hh<=tt)
{
auto t=q[hh++];//编号
for(int i=h[t];i!=-1;i=ne[i])//这里h和ne数组是指向i的指针，存的是idx
{
int j=e[i];//所以要用e[i]取出编号
d[j]--;
if(!d[j])
{
q[++tt]=j;
}
}
}
if(tt==n-1)
{
for(int i=0;i<n;i++) cout<<q[i]<<" ";
}else cout<<"-1";
}
signed main()
{
cin>>n>>m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin>>a>>b;
d[b]++;
add(a,b);
}
topsort();
return 0;
}Dijkstra
Dijkstra算法详解 通俗易懂 - 知乎 (zhihu.com)
- result：已求出 最小路径的顶点
- notFound：未求出 最小路径的顶点，里面的值是 到起点的距离
每次从 「未求出最短路径的点」中 取出 距离距离起点 最近的点，以这个点为桥梁 刷新「未求出最短路径的点」的距离
朴素版
849. Dijkstra求最短路 I - AcWing题库
朴素版就是把上面的思路模拟一遍。
#include<bits/stdc++.h>
using namespace std;
const int N=510;//一定要记得开大！！
int n,m;
int g[N][N];//存权重
int dist[N];//存距离
bool st[N];
int dijkstra()
{
memset(dist,0x3f,sizeof dist);
dist[1]=0;
for(int i=1;i<n;i++)
{
int t=0;
//找最小的边
for(int j=1;j<=n;j++)//必须要从1开始，因为后面的循环会更新别的点到原点的直接距离
{
if(st[j]) continue;
if(dist[t]>dist[j]) t=j;
}
//找到最小的边了，就更新距离
for(int j=1;j<=n;j++)
{
dist[j]=min(dist[j],dist[t]+g[t][j]);
}
st[t]=true;
}
if(dist[n]==0x3f3f3f3f) return -1;
else return dist[n];
}
signed main()
{
memset(g,0x3f,sizeof g);
cin>>n>>m;
while(m--)
{
int x,y,z;
cin>>x>>y>>z;
g[x][y]=min(g[x][y],z);
}
cout<<dijkstra();
return 0;
}堆优化版
850. Dijkstra求最短路 II - AcWing题库
手写堆与优先队列的时间复杂度是一样的。
堆优化版对比朴素版的改变是，原本朴素版要找的未标记点中dist最小的点需要再一重循环，而堆可以省去。
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
typedef pair<int,int> PII;//存dist的值和编号
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool st[N];
void add(int a,int b,int c)//稀疏图用邻接表存储
{
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int dijkstra()
{
memset(dist,0x3f,sizeof dist);
dist[1]=0;
priority_queue<PII,vector<PII>,greater<PII>> heap;//小根堆
heap.push({0,1});
while(!heap.empty())
{
auto t=heap.top();
heap.pop();
int num=t.second,distance=t.first;
if(st[num]) continue;
st[num]=true;//顺着往下，没标记过的就满足条件
for(int i=h[num];i!=-1;i=ne[i])//顺着找它有关联的边更新
{
int j=e[i];
if (dist[j] > dist[num] + w[i])
{
dist[j] = dist[num] + w[i];
heap.push({dist[j], j});
}
}
}
if(dist[n]==0x3f3f3f3f) return -1;
else return dist[n];
}
signed main()
{
cin>>n>>m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
}
cout<<dijkstra();
return 0;
}bellman-ford
AcWing 853. 有边数限制的最短路 - AcWing
有边数限制，如 “最多经过 k 条边的最短距离”，就只能用bellman-ford算法。
别的情况下spfa优于此算法。
如果有负权回路，最短距离就不一定存在。但如果限制了边数，就可以存在。
#include<bits/stdc++.h>
using namespace std;
const int N=510,M=1e4+10;
int n,m,k;
struct
{
int a,b,c;
}edge[M];
int dist[N],last[N];
void bellman()
{
memset(dist,0x3f,sizeof dist);
dist[1]=0;
for(int i=1;i<=k;i++)//走k条边
{
memcpy(last,dist,sizeof dist);
for(int j=1;j<=m;j++)//所有边
{
auto t=edge[j];
dist[t.b]=min(dist[t.b],last[t.a]+t.c);
}
}
}
signed main()
{
cin>>n>>m>>k;
for(int i=1;i<=m;i++)
{
int a,b,c;
cin>>a>>b>>c;
edge[i]={a,b,c};
}
bellman();
if(dist[n]>0x3f3f3f3f/2) puts("impossible");
else cout<<dist[n];
return 0;
} spfa
他奶奶的CSDN，本来编辑完要发了都。他奶奶的一刷新没了，后面内容还有spfa、Floyd、kruskal、染色法判断二分图和匈奴牙，不想再写一遍。复习就移步a站。
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
