寒假第三周
dfs
深度优先搜索（DFS）是一种常用的搜索策略，其基本思想是从起始节点开始，沿着一条路径尽可能深入地探索，直到达到目标或无法继续为止，然后回溯到前一节点，再尝试其他可能的路径。这个过程就像是在森林中探险一样，我们会先选择一条路一直往前走，如果发现这条路不通或者到达了目的地，我们就回头寻找另一条路继续前进。
具体来说，DFS算法的步骤如下 ：
选择一个起始节点作为当前节点，并将其标记为已访问；
检查当前节点的相邻节点，选择一个未访问过的相邻节点作为下一个当前节点，并将其加入栈中；
如果当前节点没有未访问的相邻节点，则回溯到前一节点，即从栈中弹出一个节点作为当前节点；
重复步骤2和步骤3，直到栈为空或所有节点都被访问。
DFS算法通常利用递归或显式栈来实现。它的核心思想是探索尽可能深的路径，直到无法继续为止，然后回溯到前一节点继续探索其他路径 。
DFS算法在很多领域都有广泛的应用，例如图的遍历、拓扑排序、连通性分析、回溯算法以及迷宫求解等 。
题目
下面展示一些 内联代码片。
#include<bits/stdc++.h>
using namespace std;
const int N = 10;
int n;
int path[N];
bool st[N];
void dfs(int u )
{
if(u == n){
for(int i = 0;i < n;i ++) printf("%d ",path[i]);
puts("");
return;
}
for(int i = 1; i <= n;i ++)
{
if(!st[i]){
path[u] = i;
st[i] = true;
dfs(u + 1);
st[i] = false;
}
}
}
int main()
{
cin >> n;
dfs(0);
return 0;
}
bfs
广度优先搜索（BFS）是一种常见的搜索策略，其基本思想是从起始节点开始，先搜索与其最近的邻接节点，然后再搜索次近的邻接节点，依次类推，直到找到目标节点或搜索完所有节点。这个过程就像是在展开一张地图一样，我们会先查看距离起点最近的位置，然后再逐渐向外扩展。
具体来说，BFS算法的步骤如下 ：
将起始节点放入队列中；
从队列中取出一个节点，检查该节点的所有未访问的邻接节点，并将这些邻接节点都加入队列中；
重复步骤2，直到找到目标节点或队列为空。
BFS算法通常利用队列这种数据结构来实现，因为队列的特性是先进先出，可以很好地实现广度优先的搜索策略 。
BFS算法在很多领域都有广泛的应用，例如图的遍历、最短路径问题、最小上上上界上界上界问题以及迷宫求解等 。
【题目】
下面展示一些 内联代码片。
#include<iostream>
#include<stdio.h>
#include<iomanip>
#include<stack>
#include<queue>
#include<cstdlib>
#include <algorithm>
#include<string.h>
#include<math.h>
#define llu unsigned long long
using namespace std;
int n,m;
char a[1010][1010];//注意这里用的char
int vis[1010][1010]={0};
int ans[1010*1010]={0};
int dir[4][2]={0,1,0,-1,1,0,-1,0};
struct node{
int x;
int y;
}start,now;
int num=0;
int bfs(int x,int y)
{
int sum=1;
queue<node> q;
num++;
start.x=x;
start.y=y;
q.push(start);
vis[x][y]=num;
while(!q.empty())
{
now=q.front();
q.pop();
for(int i=0;i<4;i++)
{
start.x=now.x+dir[i][0];
start.y=now.y+dir[i][1];
if(start.x>=1&&start.y>=1&&start.x<=n&&start.y<=n&&vis[start.x][start.y]==0)
{
if(a[now.x][now.y]=='0'&&a[start.x][start.y]=='1'||a[now.x][now.y]=='1'&&a[start.x][start.y]=='0')
{
vis[start.x][start.y]=num;
q.push(start);
sum++;
}
}
}
}
ans[num]=sum;
return sum;
}
int main()
{
int x,y;
cin>>n>>m;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
cin >> a[i][j];
}
}
while(m--){
cin >> x >> y;
if(vis[x][y]!=0)
cout<<ans[vis[x][y]]<<endl;
else{
int sum=bfs(x,y);
cout << sum << endl;
}
}
return 0;
}
树与图的遍历
下面展示一些 内联代码片。
#include<iostream>
#include<cstring>
using namespace std;
const int N =1e5+10;
int h[N],e[2*N],ne[2*N],idx;
bool st[N];
int n,ans=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; //size表示当前子树最大数量
for(int i=h[u];i!=-1;i=ne[i]) // 遍历每一个可以到的点
{
int j=e[i];
if(st[j]) continue;
int s=dfs(j); //每一个子树的大小
size=max(size,s);
sum +=s;
}
size=max(size,n-sum-1); //出了当前这个节点所有点的数量
ans=min(ans,size);
return sum+1; //sum要加一的原因是要计算当前这个点
}
int main()
{
memset(h,-1,sizeof h);
cin >>n;
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 <iostream>
#include <cstring>
using namespace std;
const int N = 1e5 + 10;
int n, m;
int h[N], e[N], ne[N], idx;
int q[N], d[N], hh, tt;
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool topsort()
{
hh = 0, tt = -1;
// 入度为0的顶点全部入队
for (int i = 1; i <= n; i++) if (!d[i]) q[++tt] = i;
while (hh <= tt)
{
int t = q[hh++];
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
d[j]--;
if (!d[j]) q[++tt] = j;
}
}
if (tt == n - 1) return true;
return false;
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m--)
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
d[b]++;
}
if (topsort())
{
for (int i = 0; i <= tt; i++) printf("%d ", q[i]);
puts("");
}
else puts("-1");
return 0;
}
最短路
最短路思想的核心在于找到一条路径，使得这条路径上的所有边的权重（或成本）之和最小。这些路径可以是直线，也可以是曲线，取决于具体的应用场景和需求。
下面展示一些 内联代码片。
#include <cstring>
#include <iostream>
#include <algorithm>
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 = 0; i < n - 1; i ++ )
{
int t = -1;
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || 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;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);
}
printf("%d\n", dijkstra());
return 0;
}
最小生成树
初始化：将图中的所有节点看作是独立的树木，或者说是孤立的。
选择最小上界边：在所有未被选择的边中，选择最小上界边（即连接两个不同树木的边），并将其加入最小生成树中。
更新：将新加入的边的两个端点所在的树木合并为一棵新的树。
重复：重复上述步骤，直到所有节点都被包含在一棵树中，或者已经选择了n-1条边（n为图中的节点数量）。
【模版】
下面展示一些 内联代码片。
#include<bits/stdc++.h>
using namespace std;
const int N=5010,M=2e5+10;
const int INF=0x3f3f3f3f;
int n,m,cnt,ans,a[N][N],dis[M];
bool vis[N];
void prim(){
vis[1]=1;//从节点1开始
for(int i=1;i<n;i++){
int minn=INF;//查找当前最小点的边权
int pos;//并记录该节点的下标
for(int j=1;j<=n;j++){
if(!vis[j] && (minn==INF || dis[j]<minn)){
minn=dis[j];//记录最小点的边权
pos=j;
}
}
vis[pos]=1;
ans+=minn;//累加答案，因为该点已经为最小生成数的边权
++cnt;
if(minn==INF) break;
//提前break,说明此时cnt一定不超过n,以此判断能否生成
//此时minn=INF,说明没有比1e9更小的边权，但当前还在循环，即还有点未遍历是否未最小生成数的边权，产生矛盾
for(int j=1;j<=n;j++){
//更新当前最小生成树到其他点的最小距离
//即：如果这点没有被访问过，而且这个点到任意一点的距离比现在到树的距离近那么更近
if(!vis[j] && dis[j]>a[pos][j]){
dis[j]=a[pos][j];//更新边权,即就将更小值放入dis数组
}
}
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)//初始化a，除了自己到自己的点为0，其余为边界值
for(int j=1;j<=n;j++)
if(i==j) a[i][j]=0;
else a[i][j]=INF;
for(int i=1;i<=m;i++){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
a[x][y]=a[y][x]=min(a[x][y],z);//避免重边
}
for(int i=1;i<=n;i++) dis[i]=a[1][i];//初始化距离数组，默认从顶点1开始计算，并把1能够到达的点放进dis数组
prim();
if(cnt>=n-1) printf("%d\n",ans);//能生成
else puts("orz");
return 0;
}
拓扑排序
下面展示一些 内联代码片。
#include<bits/stdc++.h>
using namespace std;
const int N=520;
vector<int>p[N]; //vector变长数组来写邻接表
queue<int>q; //队列操作
int d[N]; //统计入度
int n,x,cnt,ans[N]; //ans数组记录答案
int main(){
cin>>n;
for(int i=1;i<=n;i++){
while(cin>>x,x){
p[i].push_back(x); //构造邻接表
d[x]++; //记录x的入度
}
}
for(int i=1;i<=n;i++)if(!d[i])q.push(i); //寻找入度为0的点
while(q.size()){
int t=q.front();
q.pop();
ans[cnt++]=t;
for(int i=0;i<p[t].size();i++){
d[p[t][i]]--;
if(d[p[t][i]]==0)q.push(p[t][i]); //如果删除边后入度为0，就放入队列
}
}
for(int i=0;i<cnt;i++)cout<<ans[i]<<" ";
cout<<endl;
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
