acwing算法基础课笔记3（一）

第三章搜索与图论

1、深度优先搜索（dfs）

从开始一直往下找，找到底后回溯继续往下直到找完，使用栈来存储数据，具有回溯和剪枝两个概念，不具有最短性

排列数组（暴力搜索，全排列）

回溯后要把状态还原成原来的样子

#include<iostream>
using namespace std;
const int N=10;
int path[N];
bool st[N];
int n;
void dfs(int u)
{
	if(u==n)
	{
		for(int i=0;i<n;i++) cout<<path[i]<<" ";
		cout<<endl;
		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;
}

n皇后问题

#include<iostream>
using namespace std;
const int N=20;
int n;
char qp[N][N];
bool col[N],dg[N],udg[N];
void dfs(int u)
{
	if(u==n)
	{
		for(int i=0;i<n;i++) puts(qp[i]);
		cout<<endl;
		return ;
	}
	for(int i=0;i<n;i++)
	{
		if(!col[i] && !dg[u+i] && !udg[n+i-u])
		/*对于x行，y列的对角线和反对角线，可以看成函数y=+-x+b里面的截距b 
		可以看出截距有y+x和y-x两种，第二种可能小于0，所以我们为它加上n*/ 
		{
			qp[u][i]='Q';
			col[i]=dg[i+u]=udg[n+i-u]=true;
			dfs(u+1);
			col[i]=dg[i+u]=udg[n+i-u]=false;
			qp[u][i]='.';
		}
	}
}
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			qp[i][j]='.';
		}
	}
	dfs(0);
	return 0;
}

原始的解法：每一个格都有放皇后或者不放两种情况

#include<iostream>
using namespace std;
const int N=20;
int n;
char qp[N][N];
bool row[N],col[N],dg[N],udg[N];
void dfs(int x,int y,int s)
{
	if(y==n) y=0,x++;
	if(x==n)
	{
		if(s==n)
		{
			for(int i=0;i<n;i++)
			{
				puts(qp[i]);
			}
			cout<<endl;
		}
		return ;
	}
	dfs(x,y+1,s);//不放皇后
	//放皇后
	if(!row[x] && !col[y] && !dg[x+y] && !udg[n+x-y])
	{
		qp[x][y]='Q';
		row[x]=col[y]=dg[x+y]=udg[n+x-y]=true;
		dfs(x,y+1,s+1);
		row[x]=col[y]=dg[x+y]=udg[n+x-y]=false;
		qp[x][y]='.';		
	}
}
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			qp[i][j]='.';
		}
	}
	dfs(0,0,0);
	return 0;
}

2、宽度优先搜索（bfs）

从上往下一层层的搜索，有点像树的层序遍历，每次第一次到的点的路径，是该点的最短路径，具有最短性，可用于求最短问题，使用的是队列来存储，需要的空间是指数级的。

迷宫问题（手写队列）

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=110;
typedef pair<int,int> PII;
int n,m;
int g[N][N];
int d[N][N];
PII q[N*N];
int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
int bfs()
{
	int hh=0,tt=0;
	q[0]={0,0};
	memset(d, -1 ,sizeof d);
	d[0][0]=0;
	while(hh<=tt)
	{
		auto t=q[hh++];
		for(int i=0;i<4;i++)
		{
			int x=t.first+dx[i];
			int y=t.second+dy[i];
			if(x>=0 && x<n && y>=0 && y<m && g[x][y]==0 && d[x][y]==-1)
			{
				d[x][y]=d[t.first][t.second] +1;
				q[++tt]={x,y};
			}
		}
	}
	return d[n-1][m-1];
}
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			cin>>g[i][j];
		}
	}
	cout<<bfs()<<endl;
	return 0;
}

3树与图的存储

数是一种特殊的图（无环联通图），图根据之间的点边关系分为有向图和无向图，无向图可以看成特殊的有向图，每次存储两次指向。图常用邻接矩阵和邻接表来存储，更常用的是邻接表来存储；

邻接矩阵g[a，b]来存储a到b的有边，它无法存储重叠边。邻接表里面每一条单链表代表每一个点能到达那些点，表中次序无关紧要，需要插入元素时使用头插法。

ab建边，初始化-1表示没有结点

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1e5+10,M=N*2;
int h[N],e[M],ne[M],idx;
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int main()
{
	memset(h,-1,sizeof h);
	return 0;
}

4、树和图的遍历

因为树是特殊的图，图又可以说全是有向图，所以我们只需要知道有向图的遍历

深度优先遍历一条路走到黑

题目：树的重心

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1e5+10,M=N*2;
int h[N],e[M],ne[M],idx;
bool st[N];
int n;
int ans=N; 
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx,idx++;
}
int dfs(int u)
{
	st[u]=true;
	int sum=1,res=0;
	for(int i=h[u];i!=-1;i=ne[i])
	{
		int j=e[i];
		if(!st[j])
		{
			int s=dfs(j);
			res=max(res,s);
			sum+=s;
		}
	}
	res=max(res,n-sum);
	ans=min(res,ans);
	return sum;
}
int main()
{
	memset(h,-1,sizeof h);
	cin>>n;
	for(int i=0;i<n-1;i++)
	{
		int a,b;
		cin>>a>>b;
		add(a,b),add(b,a);
	}
	dfs(1);
	cout<<ans<<endl;
	return 0;
}

宽度优先遍历，适用于边长度为1，求最短路

宽搜：取队头，扩展，继续重复

 每次拓展只需要看自己单链表内的边就好了

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1e5+10;
int h[N],e[N],ne[N],idx;
int d[N],q[N];
int n,m;
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int bfs()
{
	int hh=0,tt=0;
	q[0]=1;
	memset(d,-1,sizeof d);
	d[1]=0;
	while(hh<=tt)
	{
		int t=q[hh++];
		for(int i=h[t];i!=-1;i=ne[i])
		{
			int j=e[i];
			if(d[j]==-1)
			{
				d[j]=d[t]+1;
				q[++tt]=j;
			}
		}
	}
	return d[n];
}
int main()
{
	cin>>n>>m;
	memset(h,-1,sizeof h);
	for(int i=0;i<m;i++)
	{
		int a,b;
		cin>>a>>b;
		add(a,b);
	}
	cout<<bfs()<<endl;
	return 0;
}

5,、图的拓扑序列

对于有向图来说，无向图没有

拓扑序列中的值表示所有边都是从序列较前的数到序列较后的数。所以不能有环，且要有向，所以有向无环图一定有拓扑序列。记录每个结点的入度和出度，所以入度为0的点都可以作为起点。

一个有向无环图一定存在一个入度为0的点。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1e5+10;
int h[N],e[N],ne[N],idx;
int q[N],d[N];
int n,m;
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
bool topsort()
{
	int hh=0,tt=-1;
	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!=-1;i=ne[i])
		{
			int j=e[i];
			d[j]--;
			if(!d[j]) q[++tt]=j;
		}
	}
	return tt==n-1;
}
int main()
{
	cin>>n>>m;
	memset(h,-1,sizeof h);
	for(int i=0;i<m;i++)
	{
		int a,b;
		cin>>a>>b;
		add(a,b);
		d[b]++;
	}
	if(topsort())
	{
		for(int i=0;i<n;i++) cout<<q[i]<<" ";
		cout<<endl;
	}
	else puts("-1");
	return 0;
}