第七章 暴力求解法相关知识点总结

一、简单枚举（穷举）

本方法在使用的时候，注意两点。一是确定枚举的变量。枚举的变量越少越好。二是枚举变量的取值范围，根据题意，可以进行计算和缩小。取值范围也是越小越好。

二、生成1-N不可重复的排列

void print_permutation(int n,int* A,int cur)
//n为数组A的长度，A为待排列的数组，cur为A中欲确定元素的位置 
{
	if(cur==n)//所有元素已经确定完成，输出。 
	{
		for(int i=0;i<n;i++)
		printf("%d",A[i]);
		printf("\n");
	}
	else for(int i=1;i<=n;i++)
	//A中的元素没有确定完，尝试在A[cur]填元素 
	{
		int ok=1;
		for(int j=0;j<cur;j++)
		{
			if(A[j]==i)
			ok=0;
		}
		if(ok)
		{
			A[cur]=i;
			print_permutation(n,A,cur+1);
		} 
	} 	
}

三、生成可重复的排列

下面的程序是生成已经排好序的P中的全排列。

#include<iostream>
using namespace std;
void print_permutation(int n,int* A,int *P,int cur)
//n为数组A的长度，对P数组(已经排好序)的元素进行排列，cur为A中欲确定元素的位置 
{
	if(cur==n)//所有元素已经确定完成，输出。 
	{
		for(int i=0;i<n;i++)
		printf("%d",A[i]);
		printf("\n");
	}
	else for(int i=0;i<n;i++)
	//A中的元素没有确定完，尝试在A[cur]填元素 
	{
		if(!i||P[i]!=P[i-1])
		//保证填充到A[cur]的元素要与前一个元素不同 
		{
			int c1=0,c2=0;
			for(int j=0;j<cur;j++)
			{
				if(P[i]==A[j]) c1++; 
			} 
			for(int j=0;j<n;j++)
			{
				if(P[i]==P[j]) c2++; 
			} 
			if(c1<c2)
			{
				A[cur]=P[i];
				print_permutation(n,A,P,cur+1);
			}	
		}		
	} 	
}

int main()
{
	int P[]={1,1,1};
	int A[4];
	print_permutation(3,A,P,0);
	return 0;
}

我们还可以采用<algotithm>自带的函数next_permutation(p,p+n)来进行枚举排列。

#include<iostream>
#include<algorithm>
using namespace std; 
int main()
{
	int n,p[10];
	scanf("%d",&n);
	for(int i=0;i<n;i++) scanf("%d",&p[i]);
	sort(p,p+n);
	do
	{
		for(int i=0;i<n;i++)
		printf("%d",p[i]);
		printf("\n");
		
	}while(next_permutation(p,p+n));
	return 0;
} 

四、解答树

如果某问题的解可以由多个步骤得到，而每个步骤都有若干的选择（这些选择方案集可能会依赖先前做出的选择），且可以用递归枚举法实现，则它的工作方式可以用解答树来描述。

五、增量构造法（子集生成）

讨论的集合中没有重复元素。并且集合A中所有元素编号从小到大排列。书中的代码，没有看懂。

#include<iostream>
using namespace std;
void print_subset(int n,int *A,int cur)
{
	for(int i=0;i<cur;i++)
	{
		printf("%d ",A[i]);	//打印当前集合 
	}
		printf("\n");
	int s = cur ? A[cur-1]+1:0;//确定当前元素的最小可能值 
	for(int i=s;i<n;i++)
	{
		A[cur] = i;
		print_subset(n,A,cur+1);//递归构造子集 
	}
}

int main()
{
	int A[]={};
	print_subset(3,A,0); 
	return 0;
} 

我对书中的代码进行了重写，下面的代码生成P的子集，要求：P必须排好序并且没有重复元素。

#include<iostream>
using namespace std;
void print_subset(int n,int *A,int *P,int cur)
{
	int flag=0;
	for(int i=0;i<cur;i++)
	{
		flag=1;
		printf("%d ",A[i]);	//打印当前集合 
	}
	if(flag)
	{
		printf("\n");
	}
	for(int i=0;i<n;i++)
	{
		int ok=1;
		for(int j=0;j<cur;j++)
		{
			if(P[i]==A[j]||A[cur-1]>P[i])
			ok=0;
		}
		if(ok)
		{
			A[cur] = P[i];
			print_subset(n,A,P,cur+1);//递归构造子集 	
		}
		
	}
}

int main()
{
	int A[10];
	int P[]={1,2,5,8,9};
	print_subset(5,A,P,0); 
	return 0;
} 

下面填写可以生成重复子集的代码，实际上子集生成就是递归生成全排列的过程。只是将中间步骤进行了输出。

#include<iostream>
using namespace std;
void print_subset(int n,int *A,int *P,int cur)
{
	int flag=0;
	for(int i=0;i<cur;i++)
	{
		flag=1;
		printf("%d ",A[i]);	//打印当前集合 
	}
	if(flag)
	{
		printf("\n");
	}
	for(int i=0;i<n;i++)
	{
		if(!i||P[i]!=P[i-1])
		{
			int cnt1=0,cnt2=0;
			for(int j=0;j<cur;j++)
			{
				if(P[i]==A[j])
				cnt1++;
			}
			for(int j=0;j<n;j++)
			{
				if(P[i]==P[j])
				cnt2++;
			}
			if(cnt2>cnt1&&(!cur||P[i]>=A[cur-1]))
			{
				A[cur] = P[i];
				print_subset(n,A,P,cur+1);//递归构造子集 	
			}	
			
		}

	}
}

int main()
{
	int A[10];
	int P[]={1,2,2,2};
	print_subset(4,A,P,0); 
	return 0;
} 

六、位向量法（子集生成）

位向量使用一个辅助的数组B，通过B[i]来表示i是不是在子集A中，从思路上看，位向量方通过修改可以支持不排序、重复的数组排列。缺点是可能有点慢。

#include<iostream>
#include<cstdio>
using namespace std;
void print_subset(int n,int *B ,int cur)
//位向量法 
{
	if(cur==n)
	{
		for(int i=0;i<cur;i++)
		if(B[i]) printf("%d",i);
		printf("\n");
		return ;
	} 
	B[cur]=1;
	print_subset(n,B,cur+1);
	B[cur]=0;
	print_subset(n,B,cur+1);
}
int main()
{
	int B[10];
	print_subset(3,B,0);
	return 0;
} 

七、二进制法（子集生成）

思想是和位向量法相同，但是应用了C语言特性进行编程，支持不排序和重复元素集合的子集生成，下面代码用重复元素的子集生成中，可能出现重复的子集输出。

#include<cstdio>
void print_subset(int n,int s,int *P)
{
	for(int i=0;i<n;i++)
	{
		if(s&(1<<i)) printf("%d ",P[i]);
	}
	printf("\n");
}
int main()
{
	int n=3;
	int P[]={1,2,3};
	for(int i=0;i<(1<<n);i++)
	print_subset(n,i,P);
	
	return 0;
}

八、八皇后问题

八皇后问题通过行-列和行+列来判断是否在一个对角线上，值得借鉴。

九、路径寻找问题

实际上就是在BFS上面加上了一个状态数组，状态数组来适应图的动态变化，并且介绍了3种方法来查找动态数组的方式，使用hash是最快的，但是设计hash函数相当困难，可以先用set实现一个慢的代码，再改写。

状态空间搜索方法的一般含有：

状态改变函数

获得结果判断函数

判定状态是否已经被访问过

存储父节点的空间（以便反向搜索到路径）

十、迭代加深搜索(IDA*)

对于搜索层数不确定的，或者很难估计的题目，可以使用迭代加深搜索，可以设计一个乐观函数来进行剪枝。而深度从小到大搜索，这样避免了深度选择太大，进行无谓的搜索。

基本的框架：

int ok=0;
for(maxd =1 ; ; maxd++)
{
	memset(ans,-1,sizeof(ans));
	if(dfs(input1,input2))
	{
		ok=1;
		break;
	}
} 

IDA*方法一般含有：

状态改变函数

获得结果判断函数

乐观估计函数H

根据深度存储路径的空间

IDA*的优势就是不用去存储太多的父节点空间，并且不用去判断状态是否被访问，这样这部分的空间也被释放，但是难点在于H函数的设计，设计的好，节约时间，不好，超时。

总的而言，状态空间搜索方法就是BFS的升级版，而IDA*则是DFS的升级版。