dfs.1

深度优先搜索（dfs）

排列数字

给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

输入格式
共一行，包含一个整数 n。

输出格式
按字典序输出所有排列方案，每个方案占一行。

数据范围
1≤n≤7
输入样例：
3
输出样例：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

#include<iostream>

using namespace std;

const int N=10;
int n;
int a[N];
bool b_l[N];

void dfs(int u)
{
    if(u==n) 
    {
        for(int i=1;i<=n;i++)
            cout<<a[i]<<" ";
        cout<<endl; 
        return ;
    }
    for(int i=1;i<=n;i++)
        if(!b_l[i])
        {
            a[u+1]=i;
            b_l[i]=true;
            dfs(u+1);
            b_l[i]=false;
        }
}

int main()
{
    cin>>n;
    dfs(0);
    return 0;
}

组合数（排列数字进阶版(个人认为的)）
http://oj.ecustacm.cn/problem.php?id=1116

从自然数1，2，…，n，从中任取r个数，输出所有组合。
输入
一行两个自然数n、r(1<n<21，1≤r≤n)。
输出
所有的组合，每一个组合占一行且其中的元素按由小到大的顺序排列，
每个元素占三个字符的位置，所有的组合也按字典顺序。
样例输入 Copy
5 3
样例输出 Copy
  1  2  3
  1  2  4
  1  2  5
  1  3  4
  1  3  5
  1  4  5
  2  3  4
  2  3  5
  2  4  5
  3  4  5

#include<iostream>

using namespace std;
int n,r;
const int N=30;
int a[N];
int vis[N]; 

void dfs(int u,int x)
{
	if(x==n+2) return;
	if(u==r+1)
	{
		for(int i=1;i<=r;i++)
		{
			if(a[i]<10) cout<<"  "<<a[i];
			else cout<<" "<<a[i];
			//每个元素占三个字符的位置
		}
		cout<<endl;
		return;
	}
	for(int i=x;i<=n;i++)
	{
		if(vis[i]==0)
		{
			a[u]=i;
			vis[i]=1;
			dfs(u+1,i+1);
			vis[i]=0;
		}
	}
}

int main()
{
	cin>>n>>r;
	dfs(1,1);
	return 0;
} 

n-皇后问题
第一种解法
第一种解法是dfs中最朴素的做法

#include<iostream>

using namespace std;

const int N=100;
int n;
char g[N][N]; 
bool col[N],row[N],dg[N],udg[N];
//dg[]与udg[]
/*
	对角线与反对角线
	对于任何一个对角线都有一个截距b
	对于在同一条线上的点，我们在这里使用截距b，来代替同一条线上的所有点
	（单纯的理解可能不容易，代码的下面有张图可以帮助进行理解）
*/
void dfs(int x,int y ,int s)
{
	if(y==n) y=0,x++;
	//y==n 意思是此时的y已经越界了
	//直接进行换行
	if(x==n) 
	{
		if(s==n) 
		{
			for(int i=0;i<n;i++)
			{
				for(int j=0;j<n;j++)
					cout<<g[i][j];
				cout<<endl;
			}
			cout<<endl;
		}
		return;
	}
	//不放皇后 
	dfs(x,y+1,s);
	//放皇后
	if(!row[x]&&!col[y]&&!dg[x+y]&&!udg[n-y+x])
	{
		g[x][y]='Q';
		row[x]=col[y]=dg[x+y]=udg[n-y+x]=true;
		dfs(x,y+1,s+1);
		row[x]=col[y]=dg[x+y]=udg[n-y+x]=false;
		g[x][y]='.';
	}
}

int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			g[i][j]='.';
	dfs(0,0,0);
	return 0;
}

在红框的内部，y=-x+b,b=x+y; b=4;
(3,1),(2,2),(1,3)
以对角线为例，(反对角线是同样的道理)
当我们使用上述的某一点标记为皇后的时候，
我们要保证在这个点的对角线上没有皇后，
我们用dg[x+y]来标记，该对角线上是否存在皇后

如果dg[x+y]==true;
//x+y表示的是截距b,在这几个点(3,1),(2,2),(1,3) 上是b是一样的
说明在这个对角线上存在皇后，
反之则不存在皇后

(可能还是有一点点的抽象，但是通过画图，应该是能够理解的)

第二种解法
第二种解法是在第一种解法上做的一些优化

#include<iostream>

using namespace std;

const int N=100;
int n;
char g[N][N];
bool col[N],dg[N],udg[N];

void dfs(int u)
{
	if(u==n) 
	{
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<n;j++)
				cout<<g[i][j];
			cout<<endl;
		}
		cout<<endl;
		return ;
	}	
	for(int i=0;i<n;i++)
	{
		if(!col[i]&&!dg[u+i]&&!udg[n-u+i])
		{
			g[u][i]='Q';
			col[i]=dg[u+i]=udg[n-u+i]=true;
			dfs(u+1);
			col[i]=dg[u+i]=udg[n-u+i]=false;
			g[u][i]='.';
		}
	}
}

int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++) 
			g[i][j]='.';
	dfs(0);
	return 0;
}

蓝桥杯-全球变暖（连通块问题）

你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。
例如上图就有2座岛屿。  
由于全球变暖导致了海面上升，科学家预测未来几十年，
岛屿边缘一个像素的范围会被海水淹没。
具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，
它就会被淹没。  
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
输入
第一行包含一个整数N。  (1 <= N <= 1000)  
以下N行N列代表一张海域照片。  
照片保证第1行、第1列、第N行、第N列的像素都是海洋。  
输出
一个整数表示答案。
样例输入
7 
.......
.##....
.##....
....##.
..####.
...###.
.......  
样例输出 
1

最朴素的做法就是
分别统计出岛屿淹没前后的数量，两者相减，即为所求的结果

下面是进行优化过的解法

#include<iostream>
#include<cstring>
using namespace std;

const int N=1010;
char a[N][N];
int ans[1000001];
//ans数组空间大小要确保1000*1000
int  b_l[N][N];
int n;

void dfs(int x,int y,int s)
{
	if(x<1||x>n||y<1||y>n) return;
	if(b_l[x][y]>0||a[x][y]!='#') return;
	b_l[x][y]=1;
if(a[x+1][y]=='#'&&a[x-1][y]=='#'&&a[x][y+1]=='#'&&a[x][y-1]=='#')
	 ans[s]++;
	 //s表示第几个岛屿
	 //ans[s]表示岛屿进行一次淹没后还剩多少个格子
	dfs(x,y+1,s);
	dfs(x,y-1,s);
	dfs(x+1,y,s);
	dfs(x-1,y,s);
}

int main()
{
	int num,idx=0;
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)	
			cin>>a[i][j];
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			if(a[i][j]=='#'&&b_l[i][j]==0) dfs(i,j,++idx);
		}
	}
	//idx表示淹没前的岛屿的数量
	for(int i=1;i<=idx;i++)
	{
		if(ans[i]==0) num++;
		//if(ans[i]>0) nn++; nn表示剩余的岛屿
	}
	cout<<num;
	return 0;	
}