NEUQ-ACM预备队week4

NEUQ-ACM预备队week4

学习算法:深度优先搜索(DFS)和广度优先搜索(BFS),queue,pair

实质:回溯算法(并不高效但能解决复杂问题)

• DFS用于求出方案总数类

• BFS用于解决最短路径类问题

DFS引入(排列组合问题)

全排列(P1706):

#include<bits/stdc++.h>
using namespace std;
int a[100],book[100],n;
void dfs(int step){
	if(step==n+1)           //达到终止条件,输出
	{
		for(int i=1;i<=n;i++) {           //全排列 
		cout<<setw(5)<<a[i];}          //控制场宽
		cout<<endl;
		return;
	}
	for(int i=1;i<=n;i++)
	{
		if(book[i]==0){
			a[step]=i;
			book[i]=1;
			dfs(step+1);
			book[i]=0;
		}
	}
}
int main(){
	cin>>n;
	dfs(1);
	return 0;
} 

组合

#include<bits/stdc++.h>
using namespace std;
int a[100],book[100],n,m;
void dfs(int step,int last){     //区别为要判断这个数前面是否出现过
	int i;
	if(step>m)
	{
		for(int i=1;i<=m;i++) {           //组合 
		cout<<setw(3)<<a[i];}
			cout<<endl;
			return;
	}
	for(i=1;i<=n;i++)
	{
		if(book[i]==0&&i>last){   //多来个判断条件
			a[step]=i;
			book[i]=1;
			dfs(step+1,i);
			book[i]=0;
		}
	}
}
int main(){
	cin>>n>>m;
	dfs(1,0);
	return 0;
} 

1.迷宫(P1605)DFS

题目

给定一个 $N\times M$ 方格的迷宫，迷宫里有 $T$ 处障碍，障碍处不可通过。

在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。

输入

第一行为三个正整数 $N,M,T$，分别表示迷宫的长宽和障碍总数。

第二行为四个正整数 $SX,SY,FX,FY$，$SX,SY$ 代表起点坐标，$FX,FY$ 代表终点坐标。

接下来 $T$ 行，每行两个正整数，表示障碍点的坐标。

输出

输出从起点坐标到终点坐标的方案总数。

题解

#include<iostream>
using namespace std;
int a[10][10],n,m,t,sx,sy,fx,fy,x,y,ans;
int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};       //四个方向对应好即可,反正循环四次,都会考虑到
void dfs(int x,int y){
	if(x==fx&&y==fy){        //判断是否搜索完成,达到终止条件则输出
		ans++;
		return;
	}
	for(int i=0;i<=3;i++){        //遍历上下左右,判断下一步往哪里走
		if(a[x+dx[i]][y+dy[i]]==1){
			a[x+dx[i]][y+dy[i]]=0;
			dfs(x+dx[i],y+dy[i]);
			a[x+dx[i]][y+dy[i]]=1;
		}
	}
}
int main(){
    cin>>n>>m>>t;
    cin>>sx>>sy>>fx>>fy;
    for(int i=1;i<=n;i++)
    	for(int j=1;j<=m;j++){
    		a[i][j]=1;  
		}
		for(int i=0;i<t;i++){
			cin>>x>>y;
			a[x][y]=0;    //障碍点
		}
	a[sx][sy]=0;
	dfs(sx,sy);
	cout<<ans;
    return 0;
}

2.马的遍历(P1443)BFS

BFS模板(cv的)

void bfs()
{
	while(q.empty()==false)///队列非空
	{
		int x=q.front().first,y=q.front().second;//取出队首 
		q.pop();//队首出队
		for (int i=1;i<=n;i++)//n个方向 
		{
			int xx=x+dx[i],yy=y+dy[i];
			if (xx>=1 && xx<=n && yy>=1 && yy<=m && vis[xx][yy]==false) //未出界，未被访问过
			{
				vis[xx][yy]=true;//标记 
				q.push(make_pair(xx,yy));//入队
				ans[xx][yy]=ans[x][y]+1;//步数+1 
			} 
		} 
	} 
}

queue用法
queue的头文件：#include

1. 入队：如q.push(x):将x元素接到队列的末端；
2. 出队：如q.pop() 弹出队列的第一个元素，并不会返回元素的值；
3. 访问队首元素：如q.front()
4. 访问队尾元素：如q.back();
5. 访问队中的元素个数：如q.size();
6. 判断队列是否为空：q.empty()

pair用法

make_pair(int,int)

思路:BFS模板题,熟悉基本结构(写在代码注释里了)

#include<bits/stdc++.h>
using namespace std;
queue<pair<int,int> >q;    //视频里讲的pair 
int ans[405][405],vis[405][405];
int nx[9]={0,2,2,1,1,-1,-1,-2,-2};
int ny[9]={0,1,-1,2,-2,2,-2,1,-1};
int n,m,x,y,xx,yy; 

void bfs(){
	while(!q.empty())   //模板 
	{
		x=q.front().first,y=q.front().second;  //取出第一组的前后 
		q.pop();
		for(int i=1;i<=8;i++){
			int xx=x+nx[i];
			int yy=y+ny[i];
			if(xx>=1&&yy>=1&&xx<=n&&yy<=m&&vis[xx][yy]==0)  //n个方向 
			{
				vis[xx][yy]=1;    //标志 
				q.push(make_pair(xx,yy));  //入队 
				ans[xx][yy]=ans[x][y]+1;   //记录每个点位步数 
		}
	}	
	} 
} 
int main(){
    cin>>n>>m>>x>>y;
    memset(ans,-1,sizeof(ans));    //初始化(恰好不可到达输出-1) 
    ans[x][y]=0;vis[x][y]=1;
    q.push(make_pair(x,y));
    
    bfs();   //此处将ans答案数组修改好即可 
    for(int i=1;i<=n;i++){  //按格式输出 
    	for(int j=1;j<=m;j++) printf("%-5d",ans[i][j]);   //"%-5d"向后限位符(加符号) 
    	cout<<endl;
	}
    return 0;
}