dfs深度优先搜索入门专练

洛谷P1706 全排列问题

题目描述
输出自然数 1 到 n 所有不重复的排列，即 n的全排列，要求所产生的任一数字序列中不允许出现重复的数字。

输入格式
一个整数 n。

输出格式
由 1 ∼n 组成的所有不重复的数字序列，每行一个序列。

每个数字保留 5 个场宽。

样例输入
3
样例输出
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
说明/提示
1≤n≤9

#include<iostream>
using namespace std;
int n;
int a[10];
bool vis[10];
void dfs(int x){
    if(x==n+1){
        for(int i=1;i<=n;i++){
            cout<<"    "<<a[i];
        }
        cout<<endl;
        return;
    }
    for(int i=1;i<=n;i++){
        if(!vis[i]){
            a[x]=i;
            vis[i]=true;
            dfs(x+1);
            vis[i]=false;
        }
    }
    return;
}
int main()
{
	cin>>n;
	dfs(1);
	return 0;
}

洛谷P1036 [NOIP2002 普及组] 选数

#include<iostream>
#include<cmath>
using namespace std;
int n,k;
int a[5000001];
int ans=0;
bool vis[21];
int p[21];
int sum;
bool isPrime(int x){
    for(int i=2;i<=sqrt(x);i++){
        if(x%i==0) return false;
    }
    return true;
}
void dfs(int x){
    if(x==k+1){
        //cout<<endl;
        if(isPrime(sum)){
            ans++;
        }
        return;
    }
    for(int i=1;i<=n;i++){
        if(!vis[i] && i>p[x-1]){//p[x-1]:第x-1个位置上的数字，i>p[x-1]保证一组加数升序排列（目的是不重复，顺序不同的按一组计）
            p[x]=i;
            //cout<<a[i]<<" ";
            sum+=a[i];
            vis[i]=true;
            dfs(x+1);
            sum-=a[i];
            vis[i]=false;
        }
    }
    return;
}

int main()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++){
        cin>>a[i];
        //p[i]=i;
	}
	dfs(1);
	cout<<ans<<endl;
	return 0;
}

Codeup【递归入门】组合的输出

时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
排列与组合是常用的数学方法，其中组合就是从n个元素中抽出r个元素(不分顺序且r < ＝ n)，我们可以简单地将n个元素理解为自然数1，2，…，n，从中任取r个数。
现要求你不用递归的方法输出所有组合。
例如n ＝ 5 ，r ＝ 3 ，所有组合为：
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
输入
一行两个自然数n、r ( 1 < n < 21，1 < ＝ r < ＝ n )。

输出
所有的组合，每一个组合占一行且其中的元素按由小到大的顺序排列，所有的组合也按字典顺序。

#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int n,r;
int p[25];
bool vis[25];
void dfs(int x){
    if(x==r+1){
        for(int i=1;i<=x-1;i++){
            printf("%d ",p[i]);
        }
        printf("\n");
        return;
    }
    for(int i=1;i<=n;i++){
        if(!vis[i] && i>p[x-1]){
            p[x]=i;
            vis[i]=true;
            dfs(x+1);
            vis[i]=false;
        }
    }
    return;
}
int main()
{
    scanf("%d%d",&n,&r);
	//cin>>n>>r;
	dfs(1);
	return 0;
}

Codeup【递归入门】n皇后 问题（原始的8皇后问题）

时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上（有8 * 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。

输入
一个整数n（ 1 < = n < = 10 )

输出
每行输出对应一种方案，按字典序输出所有方案。每种方案顺序输出皇后所在的列号，相邻两数之间用空格隔开。如果一组可行方案都没有，输出“no solute!”

样例输入
4
样例输出
2 4 1 3
3 1 4 2

• n皇后问题实际上是一个全排列+筛选的问题，n皇后会生成一个数组，数组下标表示第几列，而数组内容表示第几行，这种设计思路本身就排除了皇后在同一行或者同一列的情况。
• n皇后的是否合法的判断条件是是否有两个皇后在一条对角线上。是否在对角线上，可以通过判断，两个皇后的行列位置差是否相等，即两者行相减的绝对值和列相减的绝对值是否相等，来判断是否在对角线上。
• 因此，这道题的思路是给出n个数的所有排列组合，然后对这些全排列进行判断，合法的话，计数器+1，打印出排列顺序。

#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;

bool vis[12];
int a[12];
int n,flag,sum=0;

void dfs(int x){
	if(x==n+1){
		flag=1;
		for(int i=1;i<=n;i++){
			for(int j=i+1;j<=n;j++){
				if(abs(a[i]-a[j])==abs(i-j)){
					flag=0;
					break;
				}
			}
		}
		if(flag==1){
			sum++;
			for(int i=1;i<=n;i++){
				printf("%d ",a[i]);
			}
			printf("\n");
		}
		return;
	}
		
	for(int i=1;i<=n;i++){
		if(!vis[i]){
			a[x]=i;
			vis[i]=true;
			dfs(x+1);
			vis[i]=false;
		}
	}
	return;
}

int main()
{
    scanf("%d",&n);
	dfs(1);
	if(sum==0)
		printf("no solute!");
	return 0;
}

Codeup【递归入门】走迷宫

时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述

有一个nm格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这nm个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息(用-l表示无路)。
　　请统一用 左上右下的顺序拓展，也就是 (0,-1),(-1,0),(0,1),(1,0)

输入
第一行是两个数n，m( 1 < n ， m < 15 )，接下来是m行n列由1和0组成的数据，最后两行是起始点和结束点。

输出
　　所有可行的路径，描述一个点时用(x，y)的形式，除开始点外，其他的都要用“->”表示方向。
　　如果没有一条可行的路则输出-1。

样例输入
5 6
1 0 0 1 0 1
1 1 1 1 1 1
0 0 1 1 1 0
1 1 1 1 1 0
1 1 1 0 1 1
1 1
5 6
样例输出
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)

#include <iostream>
#include <cstdio>
using namespace std;
int n,m;
int Map[20][20];
int sx,sy;
int ex,ey;
int flag=0;
int dir[4][2]={{0,-1},{-1,0},{0,1},{1,0}};
bool vis[20][20];
struct node{
    int xx,yy;
}a[10000];
void dfs(int x,int y,int index){
    if(x==ex && y==ey){
        flag=1;
        for(int i=0;i<index;i++){
            printf("(%d,%d)->",a[i].xx,a[i].yy);
        }
        printf("(%d,%d)\n",ex,ey);
        return;
    }

    a[index].xx=x;
    a[index].yy=y;
    for(int i=0;i<4;i++){
        int nx=x+dir[i][0];
        int ny=y+dir[i][1];
        if(Map[nx][ny]&&!vis[nx][ny]&&nx>=1&&nx<=n&&ny>=1&&ny<=m){
            vis[nx][ny]=true;
            dfs(nx,ny,index+1);
            vis[nx][ny]=false;
        }
    }
    return;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&Map[i][j]);
        }
    }
    cin>>sx>>sy;
    cin>>ex>>ey;
    vis[sx][sy]=true;//一定不要忘记把起点置为访问过
    dfs(sx,sy,0);
    if(flag==0){
        cout<<"-1"<<endl;
    }
    return 0;
}