算法入门竞赛经典第二版 八皇后问题可重复子集生成

1.子集生成：

方法一，位向量法；
思路：
利用一个数组，来记录取的数字，又2种情况；
一种取，另一种不取：
直到考虑到最后，每个位置都考虑到了的话，就直接输出：
代码：

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

核心和注意点：

a[pos]=true;（选取这个数字）
	dfs(a,n,pos+1);//考虑下一个数字；
	a[pos]=false;（不选这个数字）
	dfs(a,n,pos+1);//不考虑下一个数字

if(pos==n)//考虑到最后一位了
	{
		for(int i=0;i<pos;++i)//直接输出
		{
			if(a[i]) cout<<i<<" "; //如果当前数字有取得的话输出
		}
		cout<<endl;
		return ;关键关键关键一定一定一定要返回上一层递归要 
	}

递归树如下：

方法二：增量构造法
每次选取一个集合数字进去，每次进去后就把新的集合输出到最后了就直接结束；
递归树：

代码：

#include <iostream>
using namespace std;
int n;
int a[10010];
void dfs(int n,int a[],int pos)
{
	for(int i=0;i<pos;++i)
	{
		cout<<a[i]<<' ';//每次生成一个集合就直接输出
	}
	cout<<endl;
	int s=pos?a[pos-1]+1:0;//考虑当前集合的第一个值是多少
	for(int i=s;i<n;++i)
	{
		a[pos]=i;//从当前可以考虑的最小值，开始考虑，递归，放在循环里面就是把当前可以循环分支的数字全部分出来
		dfs(n,a,pos+1);
	}
}
int main()
{
	cin>>n;
	dfs(n,a,0);
}

核心：

int s=pos?a[pos-1]+1:0;//考虑当前集合的第一个值是多少
	for(int i=s;i<n;++i)

要确定出顺序，我们就每次保证后面的数字大于当前的数字；
用循环表示，直接可以把当前的s开头的数字，全部递归树表示出来；
3.二进制法：

从右边开始往左边进去取数；
比如0111可以看成是
1取 0 不取；
从右边向左边
0 ，1，2取，3不取；
既是0 1 2；
我们可以发现一个小技巧如果集合a写成10110 就是表示 1 2 4；b写成01100 表示 2 3；
a&b=00100就是表示交集2；
a|b表示并集
a^b表示并集后交集的余集
代码：

#include <iostream>
using namespace std;
int n;
void print_subset(int n,int s)
{
	for(int i=0;i<n;++i)//每次冲头往后开始看数字
	{
		if(s&(1<<i)) cout<<" "<<i;//如果是1就代表取了，就输出
	}
	cout<<endl;

}
int main()
{
	cin>>n;
	for(int i = 0;i<(1<<n);++i)//我们发现1<<n就是子集的个数2的n次方;
	{
		print_subset(n,i);
	}
}

2.八皇后以及位置打印（dfs路径输出）
dfs的路径输出注意点：
1.每次把当前选择的东西抽象成一个答案记录下来；
2.注意回溯，因为要输出所有的解，每次输出玩路径的话，都要回溯，把路径恢复到之前状态//一般是num–；
3.**一定要到终点再输出答案数组；因为递归是不断判断选数字，再判断的过程；我们要全部判断完后才算递归结束，得出所有解；

思路：
每次考虑一行
不断判断是否可以选，可以就选，不可以判断下一个是否可以选；每次选的话就在答案数组里面加上去，每次回溯的话，不仅要把位置复原，也要把答案数组复原一下下，不然会重复：
代码：

#include <iostream>
using namespace std;
int ans,num,n;
int a[10010];
bool col[10],x1[20],x2[20];
void dfs(int pos)
{
	if(pos==n)//当考虑到最后一个位，就直接输出
	{
		for(int i=0;i<n;++i)
		{
			cout<<a[i]<<" ";
		}
		cout<<endl;
		ans++;
		return ;
	}
	for(int j=0;j<n;++j)//从0开始不断考虑是否能在该列填下去；
	{
		if(!col[j]&&!x1[pos+j]&&!x2[pos-j+8])//如果当前可以选的话
		{
			col[j]=x1[pos+j]=x2[pos-j+8]=true;//判断是true
			a[num++]=j;//把答案填下去
			dfs(pos+1);//递归下一个
			num--;//无法递归要回溯num--；
			col[j]=x1[pos+j]=x2[pos-j+8]=false;//改为false
			
		}
	}
}
int main()
{
	cin>>n;
	dfs(0);
	cout<<ans<<endl;
	return 0;
}

技巧：
不能每次输入数字后再输出，这样没有递归的话会出去；
要到最后条件的时候再输出递归：
例题：八皇后
代码：

#include <iostream>
using namespace std;
int ans,num,n,t;
int a[10010];
bool col[10],x1[20],x2[20];
void dfs(int pos)
{
	if(pos>n)
	{
		if(t<=2)
		{
			for(int i=0;i<n;++i)
		{
			cout<<a[i]<<" ";
		}
		cout<<endl;
		}
		t++;
		ans++;
		return ;
	}
	for(int j=1;j<=n;++j)
	{
		if(!col[j]&&!x1[pos+j]&&!x2[pos-j+8])
		{
			col[j]=x1[pos+j]=x2[pos-j+8]=true;
			a[num++]=j;
			dfs(pos+1);
			num--;
			col[j]=x1[pos+j]=x2[pos-j+8]=false;
			
		}
	}
}
int main()
{
	cin>>n;
	dfs(1);
	cout<<ans<<endl;
	return 0;
}

例题：
奶牛
思路：
每次判断下一步能不能走，能走就走，不能走就回来，既然要回来，那之前试过的不能走的路径要清0，回溯；
代码：

#include<bits/stdc++.h>
using namespace std;
int r,c,num=1,ans[10000][2],vis[120][80];
char a[120][80];
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
void print() {
	for(int i=1;i<=num;i++)
		cout<<ans[i][0]<<" "<<ans[i][1]<<endl;
}
void dfs(int x,int y) {
	if(x==r&&y==c)
	{
		print();
		exit(0);
	}
	for(int i=0;i<4;++i)
	{
		int dx=x+dir[i][0];
		int dy=y+dir[i][1];
		if(dx>=1&&dx<=r&&dy>=1&&dy<=c&&!vis[dx][dy]&&a[dx][dy]=='.')//如果下一个可以走的话
		{
			vis[dx][dy]=true;//走
			num++;//路径就加上去
			ans[num][0]=dx;
			ans[num][1]=dy;
			dfs(dx,dy);
			num--;//走不了不能走的路径要减少，回溯
			
		}
		
	}
}
int main() {	
	cin>>r>>c;
	for(int i=1;i<=r;i++)
		for(int j=1;j<=c;j++)
			cin>>a[i][j];
	vis[1][1]=1;
	ans[1][0]=1;
	ans[1][1]=1;
	dfs(1,1);
	return 0;
}

注意：
1.起点要初始化；
2.到最后结束一大个程序，直接exit（0）；