dfs小题

题目一：

会思考的小明 
Problem Description
小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
请填写该整数，不要填写任何多余的内容或说明文字。
Input
无 
Output
输出一个整数

Tips: 1.return 放在符合条件的 下一个状态。2.dfs初值不确定时，带入转移式看看。

#include<iostream>
using namespace std;
//13种卡牌，每种都可以取0~4张，一共取13张。 
int sum=0;
void dfs(int n,int card)
{
	if(n>13||card>13)
		return;			//return 还是要放在符合条件的 下一个状态。 
	if(card==13&&n==13) //即时n=13在card=13之前就完成了，但我还是要遍历到card=13. 
	{
		sum++;
	}
	for(int i=0;i<=4;i++)
		dfs(n+i,card+1);//很巧妙的，卡牌从1~13，是通过 参数card+1来传递。 这样return回来，i就会进入下一个值 
}
int main()
{
	dfs(0,0); 
	cout<<sum<<endl;
	return 0;
}
/*两层for循环行不行呢？ 
	int n=0;
	for(int i=1;i<=13;i++)
	{
		for(int j=0;j<=4;j++)
		{
			n+=j;//不行，break掉后，每次又是从0开始 
			break; 
		}
	}
*/

 题目二：

填数方案数 
Problem Description
如下的10个格子

填入0~9的数字。要求：连续的两个数字不能相邻。（左右、上下、对角都算相邻）
一共有多少种可能的填数方案？
Input
无 
Output
输出一个整数 

#include<iostream>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
int mmap[3][4];
int vis[10];
int dir[8][2]={ {1,0},{1,1},{1,-1},{0,1},{0,-1},{-1,0},{-1,1},{-1,-1} };
int cnt=0;
//把十个空dfs完 再check看是否满足要求 
bool check()
{
	for(int x=0;x<3;x++)
	{
		for(int y=0;y<4;y++)
		{
			if(x==0&&y==0)	continue;
			if(x==2&&y==3)	continue;
			for(int i=0;i<8;i++)
			{
				int xx=x+dir[i][0];
				int yy=y+dir[i][1];
				if(xx==0&&yy==0) continue;
				if(xx==2&&yy==3) continue;
				if(xx<0||xx>2||yy<0||yy>3) continue;
				if(abs(mmap[xx][yy]-mmap[x][y])==1)
					return false;
			}			
		}
	}
	return true;
}
void dfs(int x,int y)
{
	if(x==2&&y==3)//注意这个地方一定是到2,3的时候check，而不是2,2 
	{
		if(check())
	 		cnt++;
		return;//只要十个空填完就return 
	}
	for(int i=0;i<=9;i++)
	{
		if(vis[i]==0)
		{
			mmap[x][y]=i;
			vis[i]=1;
			if(y!=3) dfs(x,y+1);//还可以采取dfs(t)次数t从0~10，坐标t/4，t%4 
			else	dfs(x+1,0);
			vis[i]=0;
		}
	}
}
int main()
{
	dfs(0,1);
	cout<<cnt<<endl;
	return 0;
}

题目三：

公差最小的等差素数列 
Problem Description
2,3,5,7,11,13,....是素数序列。
类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。
这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为10的等差素数列，其公差最小值是多少？
注意：需要提交的是一个整数，不要填写任何多余的内容和说明文字。 
Input
无 
Output
一个整数，即程度为10的等差素数列的最小公差 

#include<iostream>
using namespace std;
#define N 1000009
int prime[N],tot=0;
int num[N];
int check(int x)
{
	if(x==2) return 1;
	if(x%2==0) return 0;
	else{
		for(int i=2;i*i<=x;i++)
			if(x%i==0)
				return 0;
		return 1;
	}
}
void init()
{
	for(int i=2;i<N;i++)
		if(check(i))
		{
			prime[tot++]=i;	
			num[i]=1;	
		}
}
int main()
{
	init();
	int flag;
	for(int i=1;i*10<N;i++){	 //枚举公差 
		for(int j=0;j<N;j++){    //枚举起始数字 
			flag=0;
			int tmp=prime[j];
			for(int k=1;k<=9;k++){	//枚举长度 
				int ne_tmp=tmp+k*i;
				if(num[ne_tmp]!=1)
					break;
				if(k==9)
				{
					flag=1;
					cout<<i;
				//  cout<<" "<<prime[j]<<endl;
				}
			}
			if(flag) break;
		}
		if(flag) break;
	}
	return 0;
}

题目四：

振兴中华
Problem Description
小明参加了学校的趣味运动会，其中的一个项目是：跳格子。
地上画着一些格子，每个格子里写一个字，如下所示： 
从我做起振
我做起振兴
做起振兴中
起振兴中华.
比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。
要求跳过的路线刚好构成“从我做起振兴中华”这句话。
请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
答案是一个整数。
注意：不要提交解答过程，或其它辅助说明类的内容。
Input
无 
Output
一个整数 

#include<iostream>
using namespace std;
int a[4][5]={
{1,2,3,4,5},
{2,3,4,5,6},
{3,4,5,6,7},
{4,5,6,7,8}
};
int dir[4][2]={0,1,1,0,-1,0,0,-1};
int cnt=0;
void dfs(int x,int y,int dep)
{
	if(dep>8)
                return;
        if(dep==8)
		cnt++;
	for(int i=0;i<4;i++)
	{
	    	int xx=x+dir[i][0];
		int yy=y+dir[i][1];
		if(xx<0||xx>4||yy<0||yy>5)
			continue;
		if(a[xx][yy]!=dep+1)
			continue;
		dfs(xx,yy,dep+1);
	}
}
int main()
{
	dfs(0,0,1);
	cout<<cnt<<endl;
	return 0;
}

题目五：

剪方格 
Problem Description
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：p1.png, p2.png, p3.png 就是可行的分割法。

试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
请提交该整数，不要填写任何多余的内容或说明文字。 
Input
五 
Output
输出一个整数，即所有不同的分割方法的数量。 

思路：这题很巧妙，dfs深搜的是点而不是块。通常我们都是以mmap[ ][ ]来深搜块，但是这一题的思路是：以对称中心（3,3）为起点，往四个方向深搜下一个点（xx,xy）并标记，同时标记对称点(6-xx,6-yy)，这样当触碰到图形边界（X=0 || Y=0 || X=N || Y=N）的时候，搜索即完成了，这些点走过的边即分割边，而且一定是将图形分割成两个相同的部分。但是注意，因为旋转对称属于同一种，所以最终的结果ans需要除以4。

思考：1.能够发现分割线是中心对称的（与分割线的长度无关）。即想到：由 对块的遍历 ----> 对线（点）的遍历,这是前所未有的。

2.深入理解dfs是什么？它只是一种搜索的工具、或者叫方式，我们的目的是为了遍历所有可能的情况，只是采取这一种方式而已，回归本题，我们从中心对称点出发，遍历所有走过点的排列组合，而dfs return可以帮我们实现这一点。

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//这一题思路很巧妙，从对称中心点（3,3）出发，遍历点而非块，直到达到边界  
const int N = 6;
int ans = 0;
int mmap[N+1][N+1];
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void dfs(int x,int y)
{
    if(x == 0 || y == 0 || x == N || y == N) //到达边界
	 {
        ans ++;
        return;
    }
    for(int i = 0 ; i < 4 ; i ++)
    {
        int xx = x + dir[i][0];
        int yy = y + dir[i][1];
        if(mmap[xx][yy])
			continue;
        mmap[xx][yy] = 1;
        mmap[N-xx][N-yy] = 1;
        dfs(xx,yy);
        mmap[N-xx][N-yy] = 0;
        mmap[xx][yy] = 0;
    }
}
int main()
{
    mmap[N/2][N/2] = 1;
    dfs(N/2,N/2);//从对称中心开始深搜  
    printf("%d",ans/4);
    return 0;
}

题目六：不同的剪取次数

如【图1.jpg】有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。（仅仅连接一个角不算相连）
比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。
请你计算，一共有多少种不同的剪取方法。
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
Input
无 
Output
输出一个整数 

方法一：一维转二维

//首先从12数中选出5个数 用深搜(保证五个数是递增的,避免重复) ，再将五个数值转化为坐标形式 ，再check5个坐标是不是连通的。 
//再判断这5个数是否相连，用广搜 最终答案116 
#include<iostream> 
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
int a[5],vis1[15],vis2[3][4];
int dep;
int sum=0;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
struct node {
	int x,y;
}s; 
int bfs(int x1,int y1)
{
	queue<node>q;
	s.x=x1;
    s.y=y1;
	vis2[x1][y1]=0;
	dep=1;
	q.push(s);
	node m,t;
	while(!q.empty())
	{
		t=q.front();
		q.pop();
		for(int i=0;i<4;i++)
		{
			m.x=t.x+dir[i][0];
			m.y=t.y+dir[i][1];
			if(vis2[m.x][m.y]==1&&m.x>=0&&m.x<=2&&m.y>=0&&m.y<=3)
			{
				dep++;
				vis2[m.x][m.y]=0;
			//	cout<<m.x<<" "<<m.y<<endl;
				q.push(m);
			}
		}
	}
	return dep;
}/*
void check(int x,int y)
{
	if(dep<5)//dep为什么不能作为check中的一个参数呢？ 为什么这种dfs类的写法就不行呢？ 
	{
		for(int i=0;i<4;i++)
		{
			int xx=x+dir[i][0];
			int yy=y+dir[y][0];
			if(vis2[xx][yy]==1 && xx>=0&&xx<=2 && yy>=0&&yy<=3)
			{
				vis2[xx][yy]=0;
				dep++;
				check(xx,yy);
			}
		}
	}
}*/
void dfs(int n)
{
	if(n==5)
	{ 
		for(int i=0;i<3;i++)	//二维数组的初始化不能用 memset 
			for(int j=0;j<4;j++)
				vis2[i][j]=0;
		int x1,y1;
		for(int i=0;i<5;i++)
		{
			x1=(a[i]-1)/4;//记住：从0开始的，矩形一维数值，通过 / 或者 % 运算，可以转换成二维坐标。 
			y1=(a[i]-1)%4;
			vis2[x1][y1]=1;
		}
		vis2[x1][y1]=0;
		dep=1;
		bfs(x1,y1);
		if(dep==5)
			sum++;
		return;
	}
	if(n>5)
		return;
	for(int i=1;i<=12;i++)
	{
		if(vis1[i]==0&&i>a[n-1]) //之所以能保证在检查时一笔画，是因为我这里的a[]是有序的 
		{
			a[n]=i;   
		    vis1[i]=1;
			dfs(n+1); 
			vis1[i]=0;
		}
	}
} 
int main()
{
	memset(vis1,0,sizeof(vis1));
	dfs(0);
	cout<<sum;
}
/* 找五个点的模板 
void dfs(int n)
{
	if(n==5){
		
	}
	if(n>5)
		return;
	for(int i=1;i<=12;i++)
	{
		if(i>a[n]&&vis[i]==0)
		{
			
		}
	}
	
} */

方法二：直接一维

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
//枚举5个点，然后判断连通性！ 全程一维来做，没有改成坐标形式。 
int dir[5]={-4,1,-1,4};//一维下的这个点行走方法。 
int cnt,i1,i2,i3,i4,i5;
int vis[20];
void dfs(int i){
    if(cnt<5)
        for(int j=0;j<4;j++)
        {
            if((i==4||i==8)&&dir[j]==1) continue;
            if((i==5||i==9)&&dir[j]==-1) continue;
            int t=i+dir[j];
            if(cnt<5&&t>0&&t<13&&!vis[t]&&(t==i2||t==i3||t==i4||t==i5))
	        {
	            vis[t]=1;
	            cnt++;
	            dfs(t);
	        }
        }
}
int main(){
    int ans=0;
    for(i1=1;i1<=12-4;i1++)
    for(i2=i1+1;i2<=12-3;i2++)
    for(i3=i2+1;i3<=12-2;i3++)
    for(i4=i3+1;i4<=12-1;i4++)
    for(i5=i4+1;i5<=12;i5++)   //这个写法道理其实和副本二是一样的，只是更加简化了。 
    {
        memset(vis,0,sizeof(vis));
        cnt=1;
        dfs(i1);
        if(cnt==5) 
			ans++;
    }
    cout<<ans;
	return 0;
}