【算法基础】搜索与图论

DFS

全排列问题

842. 排列数字 - AcWing题库

#include
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<>n;
	dfs(1);
	
	return 0;
}

 n-皇后问题

843. n-皇后问题 - AcWing题库

题目要求同一行、同一列、同一斜线上只能有一个皇后。

我们开3个数组记录列、斜线、反斜线是否有皇后存在。

用dfs把每一行都走一遍，同时遍历列，

对每一个点，考察它的列、斜线、反斜线上是否有别的皇后，（因为行是在dfs的参数里考察的，有唯一性）

如果没有就放皇后并且标记为true

#include
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;
	for(int i=0;i

BFS

走迷宫 

844. 走迷宫 - AcWing题库

#include
using namespace std;
const int N=110;
typedef pair 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<

八数码

845. 八数码 - AcWing题库

思路： 设置开始和最后的状态，存在一个字符串里面。如“12345678x”

用bfs，每回找到队列里的x做变换，用dis记录步数

最后队头的string==end，就说明存在解决方案，输出即可

否则返回-1。

#include
using namespace std;
queue q;
unordered_map 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<

树与图的深度优先遍历

树的重心

846. 树的重心 - AcWing题库

#include
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>a>>b;
		add(a,b);
		add(b,a);
	}
	dfs(1);
	cout<

树与图的广度优先遍历

图中点的层次

847. 图中点的层次 - AcWing题库

#include
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<

拓扑排序

有向图的拓扑序列 

848. 有向图的拓扑序列 - AcWing题库

啥是拓扑排序?

一个有向图，如果图中有入度为 0 的点，就把这个点删掉，同时也删掉这个点所连的边。

一直进行上面出处理，如果所有点都能被删掉，则这个图可以进行拓扑排序。

思路：突破口是入度为0 的点

把已知的入度为0的点放进队列

只要队列不空，取出队头->t

        枚举t的所有出边t->j

                删掉t->j   j的入度--

                if（j的入度为0） 让j入队         

#include
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>>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
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;idist[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<

 堆优化版

850. Dijkstra求最短路 II - AcWing题库

手写堆与优先队列的时间复杂度是一样的。

堆优化版对比朴素版的改变是，原本朴素版要找的未标记点中dist最小的点需要再一重循环，而堆可以省去。

#include
using namespace std;
const int N=1e6+10;
typedef pair 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,greater> 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<

bellman-ford

AcWing 853. 有边数限制的最短路 - AcWing

有边数限制，如  “最多经过 k 条边的最短距离”，就只能用bellman-ford算法。

别的情况下spfa优于此算法。

如果有负权回路，最短距离就不一定存在。但如果限制了边数，就可以存在。

#include
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<

spfa

他奶奶的CSDN，本来编辑完要发了都。他奶奶的一刷新没了，后面内容还有spfa、Floyd、kruskal、染色法判断二分图和匈奴牙，不想再写一遍。复习就移步a站。