枚举-递归-回溯

一、暴力求解法（枚举法/ 穷举法）

概念：什么是枚举法？

在进行归纳推理时，如果逐个考察了某类事件的所有可能情况，因而得出一般结论，那么这结论是可靠的，这种归纳方法叫做枚举法。即，把所要解决问题的所有可能性都列举出来，一一试验。

枚举应用简单举例：求1~100之间的素数；求水仙花数；鸡兔同笼问题；百元买百鸡问题；整数（分数）拆分问题；排列问题……

枚举算法因为要列举问题的所有可能的答案，所有它具备以下几个特点：

1、得到的结果肯定是正确的；

2、可能做了很多的无用功，浪费了宝贵的时间，效率低下。

3、通常会涉及到求极值（如最大，最小，最重等）。

4、数据量大的话，可能会造成时间崩溃。

采用枚举算法解题的基本思路：

（1）确定枚举对象、枚举范围和判定条件；

（2）一一枚举可能的解，验证是否是问题的解

下面我们就从枚举算法的的优化、枚举对象的选择以及判定条件的确定，这三个方面来探讨如何用枚举法解题。

例1：百元买百鸡问题：有一个人有一百块钱，打算买一百只鸡。到市场一看，大鸡三块钱一只，小鸡一块钱三只，不大不小的鸡两块钱一只。现在，请你编一程序，帮他计划一下，怎么样买法，才能刚好用一百块钱买一百只鸡？

算法分析：

我们以三种鸡的个数为枚举对象（分别设为x,y,z），以三种鸡的总数（x+y+z）和买鸡用去的钱的总数(x*3+y*2+z/3)为判定条件，穷举各种鸡的个数。

（1）基本算法：

for (x=0;x<=100;x++)

for (y=0;y<=100;y++)

for(z=0;z<=100;z++)

if(x+y+z==100 && z%3==0 && x*3+y*2+z/3==100)输出x,y,z

（2）优化算法：只需要枚举2种鸡x（x<=33）和y（y<=50)，第3种根据约束条件100-x-y可得:

for (x=0;x<=33;x++)

for (y=0;y<=50;y++)

{

Z=100-x-y;

if (z%3==0 && x*3+y*2+z/3==100)输出x,y,z

小结：对于枚举算法，加强约束条件，缩小枚举的范围，是程序优化的主要考虑方向。

1.枚举对象的选择问题：

在枚举算法中，枚举对象的选择是非常重要的，它直接影响着算法的时间复杂度，选择适当的枚举对象可以获得更高的效率。如下例：

例2：将1,2...9共9个数分成三组，分别组成三个三位数，且使这三个三位数构成1:2:3的比例，试求出所有满足条件的三个三位数。例如：三个三位数192，384，576满足以上条件。

我们分别设三个数为x,2x,3x，以x为枚举对象，穷举的范围将大大缩小。

例3. 五猴分桃：五只猴子一起摘了一堆桃子,因为太累了,它们商量决定,先睡一觉再分.一会其中的一只猴子来了,它见别的猴子没来,便将这堆桃子平均分成5份,结果多了一个,就将多的这个吃了,并拿走其中的一份.一会儿,第2只猴子来了,他不知道已经有一个同伴来过,还以为自己是第一个到的呢,于是将地上的桃子堆起来,再一次平均分成5份,发现也多了一个,同样吃了这1个,并拿走其中一份.接着来的第3,第4,第5只猴子都是这样做的.......,

根据上面的条件,问这5只猴子至少摘了多少个桃子?第5只猴子走后还剩下多少个桃子?

算法分析：我们设总的桃子数为S0，五子猴子分得的桃子数分别为S1，S2，S3，S4，S5，则有以下关系式：S0 = 5*S1 + 1；4*S1 = 5*S2 + 1；4*S2 = 5*S3 + 1；4*S3 = 5*S4 + 1；4*S4 = 5*S5 + 1；

我们可以枚举桃子总数S0，从5开始直到满足条件，此时S0的值就是最少的总桃子数。对应程序如下：

int main(void)

{

int s[6] = {0};

int i;

for(s[0]=5; ;s[0]++)

{

s[1] = s[0] - 1;

if (s[1]%5) // （s[0] – 1）要能被5整除

else

s[1] /= 5;

s[2] = 4 * s[1] - 1;

if (s[2]%5) // （4 * s[1] - 1）要能被5整除

continue;

else

s[2] /= 5;

s[3] = 4 * s[2] - 1;

if (s[3]%5)

continue;

else

s[3] /= 5;

s[4] = 4 * s[3] - 1;

if (s[4]%5)

continue;

else

s[4] /= 5;

s[5] = 4 * s[4] - 1;

if (s[5]%5)

continue;

else

s[5] /= 5;

break; //很关键，什么时候结束枚举

}

printf("摘了%d个桃子, 剩下%d个桃子\n", s[0], s[5]*4);

for (i=0; i<6; i++)

printf("%d ", s[i]);

return 0;

}

程序输出：摘了3121个桃子, 剩下765个桃子。

根据程序结果我们知道循环体执行了3116次，同时我们可以知道第5个猴子分得255个桃子，所以如果枚举S5，则循环体只需执行了255次。对应程序如下：

#include

int main(void)

{

int s[6] = {0};

int i;

for(s[5]=1; ;s[5]++)

{

s[4] = 5 * s[5] + 1;

if (s[4]%4)

else

s[4] /= 4;

s[3] = 5 * s[4] + 1;

if (s[3]%4)

continue;

else

s[3] /= 4;

s[2] = 5 * s[3] + 1;

if (s[2]%4)

continue;

else

s[2] /= 4;

s[1] = 5 * s[2] + 1;

if (s[1]%4)

continue;

else

s[1] /= 4;

s[0] = 5 * s[1] + 1;

break;

}

printf("摘了%d个桃子, 剩下%d个桃子\n", s[0], s[5]*4);

return 0;

}

我们可以发现求S4，S3，S2，S1的表达式完全是一样的，所以我们可以用一个函数或者循环来表示，改进后的程序如下：

#include

int main(void)

{

int s[6] = {0};

int i;

for(s[5]=1; ;s[5]++)

{

for (i=4; i>0; i--)

{

s[i] = 5 * s[i+1] + 1;

if (s[i]%4)

break;

else

s[i] /= 4;

}

if (i == 0)

{

s[0] = 5 * s[1] + 1;

break;

}

}

printf("摘了%d个桃子, 剩下%d个桃子\n", s[0], s[5]*4);

return 0;

}

2.如何确定枚举范围？

例4：分数拆分问题（输入正整数k，找到所有的正整数x≥y，使得1/k=1/x+1/y。）

分析：由于x≥y，有1/x≤1/y，因此1/k-1/y≤1/y，即y≤2k。这样只需要在2k范围内枚举y，然后根据y尝试计算出x即可。

3.约束条件的确定

在枚举法解题中，判定条件的确定也是很重要的，如果约束条件不对或者不全面，就穷举不出正确的结果，我们再看看下面的例子。

例3：高斯日记。计算1777年4月30日（高斯出生日）之后第8113天的日期是多少。

例4：大小之差。由6个数字（允许重复）组成的最大6位数与最小6位数之间的差值也是一个6位数，且刚好包含了这6个数字。（2014第五届蓝桥杯校内赛C语言B组）

综合举例1：古堡算式（ABCDE * ？= EDCBA）

（1）枚举对象，可以有两种选择：

a）对每一个字符进行0~9的枚举；

b）利用一个5位数进行10000~99999的枚举；

（2）枚举范围设定

对于用5位数来枚举的方式，根据条件“各字符均不相同”、以及乘上一

个1位数后仍然是5位数的情况，可缩小枚举范围为12345~49876。

（3）约束条件，根据题目可知有两个约束条件：

a）各字符均不相同（即：A!=B && A!=C && A!=D && A!=E && B!=C && B!=D && B!=E && C!=D && C!=E && D!=E）

b）算式（即ABCDE * ？== EDCBA）

下面分别按上述两种枚举对象给出程序代码：

方法一：

#include

int x[5]; //用于存放5个字符对应的5个数字

void calc(int &a, int &b) // 计算5位数的值

{

int i;

a=b=0;

for (i=0; i<5; i++)

{

a = 10 * a + x[i];

b = 10 * b + x[5-i-1];

}

return;

}

int main(int argc, char* argv[])

{

int flag[10]={0}, a=0, b=0, t; //flag数组用于表示各数字是否被选用

for (x[0]=0; x[0]<=9; x[0]++)

{

flag[x[0]] = 1;

for (x[1]=0; x[1]<=9; x[1]++)

if (!flag[x[1]])

{

flag[x[1]] = 1;

for (x[2]=0; x[2]<=9; x[2]++)

if (!flag[x[2]])

{

flag[x[2]] = 1;

for (x[3]=0; x[3]<=9; x[3]++)

if (!flag[x[3]])

{

flag[x[3]] = 0;

for (x[4]=0; x[4]<=9; x[4]++)

if (!flag[x[4]])

{

calc(a,b);

for (t=2; t<=9; t++)

if (a*t==b) //约束条件

printf("A=%d\nB=%d\nC=%d\nD=%d\nE=%d\n?

=%d\n", x[0],x[1],x[2],x[3],x[4],t);

}

flag[x[3]] = 0;

}

flag[x[2]] = 0;

}

flag[x[1]] = 0;

}

flag[x[0]] = 0;

}

return 0;

}

方法二：

int main(int argc, char* argv[])

{

int A,B,C,D,E,t,x,y;

for (x=12345; x<=49876; x++)

{

A = x/10000;

B = (x%10000)/1000;

C = (x%1000)/100;

D = (x%100)/10;

E = x % 10;

if (A!=B && A!=C && A!=D && A!=E && B!=C && B!=D && B!=E && C!=D && C!=E && D!=E )

{

y = E*10000+D*1000+C*100+B*10+A;

for (t=2; t<=9; t++)

if (x * t==y)

printf(“A=%d\nB=%d\nC=%d\nD=%d\nE=%d\n?=%d\n",A,B,C,D,E,t);

}

}

return 0;

}

综合举例2：警察抓住A B C D四名罪犯，其中一人是小偷。审问A说：我不是小偷。B说C是小偷。C说小偷肯定是D。D说C在冤枉人。现在已经知道四个人中三人说的是真话，一个人说假话，问小偷到底是谁？

int main()

{

int a, b, c, d; //用a、b、c、d分别表示四个人是否小偷

for (a = 0; a<=1; a+ )

for (b =0; b<= 1; b++ )

for (c=0; c<=1; c++)

for (d=0; d<=1; d++)

if（a+b+c+d==1）//4个人中只有1人是小偷

if ((a==0)+ (c==1)+ (d==1) + (d==0)) ==3 ) //有三人说真话

{

if (a==1) printf(“A\n”);

if (b==1) printf(“B\n”);

if (c==1) printf(“C\n”);

if (d==1) printf(“D\n”);

return 0;

}

习题：

1.已知三位整数x和y满足：x+y=1333，其中x的个位数是y的百位数，y的个位数是x的百位数，而它们的十位数一样。求满足这样条件的x和y。

2. 三人年龄

三个神秘蒙面人来访F博士。

博士询问他们年龄时，他们说：我们中年龄最小的不超过19岁。我们3人年龄总和为70岁。且我们三人年龄的乘积是所有可能情况中最大的。

请帮助F博士计算他们的年龄，从小到大排列，用逗号分开。

3. 农妇卖鸡蛋问题

大数学家欧拉在集市上遇到了本村的两个农妇，每人跨着个空篮子。她们和欧拉打招呼说两人刚刚卖完了所有的鸡蛋。

欧拉随便问：“卖了多少鸡蛋呢？”

不料一个说：“我们两人自己卖自己的，一共卖了150个鸡蛋，虽然我们卖的鸡蛋有多有少，但刚好得了同样的钱数。你猜猜看！”

欧拉猜不出。

另一个补充道：“如果我按她那样的价格卖，可以得到32元；如果她按我的价格卖，可以得到24.5元”。

欧拉想了想，说出了正确答案。

4. 马虎的算式：假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）能满足形如：ab * cde = adb * ce 这样的算式一共有多少种呢？（第四届C语言B组预赛真题）

5. 黑洞数：任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。

比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。

请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中位数全都相同则循环圈为[0]，这个可以不考虑。

循环圈的输出格式仿照：

[82962, 75933, 63954, 61974] 其中数字的先后顺序可以不考虑。

二、递归

概念：什么是递归？

是指函数/过程/子程序在运行过程中直接或间接调用自身而产生的重入现象。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

递归算法要求

递归算法所体现的“重复”一般有三个要求：

（1）每次调用在规模上都有所缩小(通常是减半)；

（2）相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；

（3）在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而必须有一个明确的递归结束条件，称为递归出口。

递归技术分为两种类型：

(1)基于归纳的递归；

(2)基于分治的递归。

递归的应用场合：

（1）数据的是按递推方式定义的（Fibonacci函数等）

（2）问题求解过程适于递归（数的排列问题等）

（3）数据或问题对象的结构形式是按递归定义的（树图的遍历，搜索回溯）递归应用举例：求n!；求斐波那契序列；汉诺塔问题；……

递归的缺点：

递归算法解题相对常用的算法如普通循环等，运行效率较低。因此，应该尽量避免使用递归，除非没有更好的算法或者某种特定情况，递归更为适合的时候。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

（一）数据的定义是按递推定义的

例1：求n!，关键：f(n)=n*f(n-1)

int f(int n)

{

if (n==0 || n==1) return 1;

return n*f(n-1);

}

例2：求斐波那契序列第n项值，关键：F(n)=F(n-1)+F(n-2)

int Fibonacci(int n)

{

if (n==0 || n==1) return n;

return Fibonacci(n-1)+ Fibonacci(n-2);

}

小结：此类问题的解题思路是运用了数学归纳法（什么是数学归纳法？）的基本思想，先求出问题规模n在边界值（通常是最小值）时候的解，再依据f(n)与前项（即f(n-1)）的递推关系，给出f(n)的运算式。

例3：计算m个A，n个B可以组合成多少个不同排列的问题。

int f(int m, int n)

{

if(m==0 || n==0) return 1;

return _（m+n）*(m+n-1)/(m*n)f(m-1,n-1); 或

_f(m-1,n)+f(m,n-1);

}

（二）问题的求解过程适于递归

递归的思想关键在于将大任务划分成小任务，要求这些小任务与大任务有相似性。

下面用几个简单的问题来理解递归思想：

例1：输出0~9这10个数

循环法：for ( x = 0; x<=9; x++ ) printf( “%d\n”, x );

递归法：void fp( int begin, int end)

{

printf (“%d\n”, begin); //先打印再递归

if ( begin < end ) fp(begin+1, end);

}

等价于：void fp ( int begin, int end)

{

if (begin > end) return; //递归的出口

fp ( begin, end-1);//先递归再打印

printf (“%d\n”, end);

}

例2：累加求和1+2+3+……+100

循环法：for ( x=1, sum=0; x<=100; x++ ) sum = sum+x;

递归法：int fsum ( int begin, int end)

{

if (begin == end) return begin; //递归的出口

return begin + fp ( begin+1, end);

}

从上述两例可以看出，递归思想的精髓在于将大任务划分为与它相似的小任务，这要如何体现？就体现在函数的“参数”变化上！

例3：汉诺塔问题

递归的思路：是将n个盘的问题转化为n-1个盘的问题，再将n-1个盘的问题转化为n-2个盘……,最后转化为处理1个盘的问题。

void hanoi(int n,char A,char B,char C)

{

if (n==1)

move (A,C);

else

{

hanoi(n-1,A,C,B); //将n-1个盘经过C柱中转搬到B柱

move (A,C); //将第n个盘从A柱搬到C柱

hanoi(n-1,B,A,C);//将n-1个盘经过A柱中转搬到C柱}

}

例4：生成1～n的全排列（分为数字可重复和不可重复）

方法一思路：建立一个由1～n组成的数组，利用任务划分，将n个数的排列问题转化为n-1个数的排列问题。具体做法：将数组中的每个数都分别与第1个数交换，然后再将剩余的数进行全排列。

void Swap(int& a, int& b) // 交换a和b

{

int temp = a;

a = b;

b = temp;

}

void Perm(int list[], int k, int m) //生成list [k：m ]的所有排列方式

{

int i;

if (k == m)

{ //输出一个排列方式

for (i = 0; i <= m; i++)

printf(“%d”,list[i]);

printf(“\n”);

}

else // list[k：m ]有多个排列方式

// 递归地产生这些排列方式

for (i=k; i <= m; i++)

{

Swap (list[k], list[i]); //将当前序列中的每个数与第一个数交换

Perm (list, k+1, m); //进入递归对后序的数列进行全排列

Swap (list [k], list [i]); //恢复交换前的状态

}

}

int main()

{

int s[]={1,2,3};

Perm(s, 0, 2);

return 0;

}

方法二思路：将n位数的排列划分成对每一个1位数的排列问题，对每个位置利用循环来尝试填数；填入一个数后，再利用递归去填入后续位置的数，…直至填完n个位置。

void print_permutation(int n, int *A, int pos)

{

int i,j;

if (pos==n)

for (i=0; i

else

for (i=1; i<=n; i++) //尝试从1～n 个数中找出填入A[pos]的数i { int ok=1;

for(j=0; j

if(ok)

{ A[pos]=i; //对当前位置填数

Print_permutation(n,A,pos+1); //递归，填写后序位置}

}

}

（三）数据的结构形式是按递归定义的

对于数据的结构形式是按递归定义的问题，直接按结构进行递进操作。

例7：二叉树的遍历（按中序遍历）

void InOrderTraverse(BiTree T)

{

if (T)

{

InOrderTraverse(T->lchild);

Visit(T->data);

InOrderTraverse(T->rchild);

}

}

习题：

1. 利用递归方式实现古堡算式。

2. 整数划分问题。任意输入一个正整数，把它的所有划分列出来。

例如：输入5

输出5 4+1 3+2 3+1+1 2+2+1 2+1+1+1 1+1+1+1+1

3．有M个小孩到公园玩，门票是1元。其中N个小孩带的钱为1元，K个小孩带的钱为2元。售票员没有零钱，问这些小孩共有多少种排队方法，使得售票员总能找得开零钱。注意：两个拿一元零钱的小孩，他们的位置互换，也算是一种新的排法。（M<=10）

三、分治法

当求解一个问题规模为n的问题，而n的取值很大时，通常把问题划分为多个子问题，这些子问题在结构上与原问题一样，但规模比原问题小，原问题的解即子问题解的合并，这种方法即为分治法。

分治法典型例子：二分查找、快速排序、归并排序等。

分治法所能解决的问题一般具有以下几个特征：

1) 该问题的规模缩小到一定的程度就可以容易地解决。

2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。

3) 利用该问题分解出的子问题的解可以合并为该问题的解；

4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。

分治法在每一层递归上都有三个步骤：

分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；

解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题；

合并：将各个子问题的解合并为原问题的解。

它的一般的算法设计模式如下：

DandC(P)

1. if |P|≤n0

小规模的问题P。

3. 将P分解为较小的子问题 P1 ,P2 ,...,Pk

4. for i←1 to k

5. do yi ← D andC(Pi) //递归解决每个Pi

6. T ← MERGE(y1,y2,...,yk) // 合并子问题

7. return(T)

例题1：最大最小问题

企业老板有一袋金块，他要从中挑选最重的一块给最优秀的员工，挑选最轻的一块给一位普通员工。这个问题实际是从n个元素中查找最大值和最小值。

求解问题的一般算法：

void max_min(int A[], int &max, int &min, int n)

{

int i;

max = A[0]; min = A[0];

for(i=1; i

{

if( A[i]>max ) max = A[i];

if( A[i]

}

}

上述算法当问题规模为n时，比较的次数是2(n-1)。

利用分治法来解决：将原数组划分成两个相同大小的子数组，再对两个子数组分别采用分治法，求出最大值和最小值，然后再对两个最大值进行比较，得出大者；对两个最小值进行比较得出小者。

程序代码如下：

void maxmin(int A[], int &max, int &min, int low, int high)

{

int mid, max1, max2, min1, min2;

if ( high - low <=1 ) //当元素个数小于等2时，直接得出最大最小值if( A[high] > A[low] { max = A[high]; min = A[low]; }

else { max = A[low]; min = A[high]; }

else

{

mid = (low + high)/2; //元素个数大于2时，分两组

maxmin( A, max1, min1, low, mid); //分别对两个小组递归

maxmin( A, max2, min2, mid+1, high);

max = max1>max2 ? max1 : max2;

min = min1

}

}

用分治法解决问题规模为n的数列，比较次数为 3n/2 -2。

例题2：求数列中的最小间距。

对于给定的任意n个数，找出其中差值最小的两个数。

问题分析：传统思路（1）分别求出每个数与其他n-1个数的差值，取最小值；（2）对数列排序，再比较所有相邻两个数的差值。这两种方法对于n较大时效率较低。

分治法：将数列按它们的均值m分为两组S1、S2，S1中元素<=m，S2中元素>m；分别对S1和S2继续划分（递归），直至组中元素个数小于等2，计算两个元素的差值；对比S1和S2中的最小差值，取小者得min；计算S2中的最小值与S1中的最大值之差，若该值

程序部分代码：

typedef struct{

int x, y;

int d;

} point_d;

int partition(int n[], int k, int low, int high)

{

int i=low,j=high, temp;

while (i

{

while (ik) j--;

while (i

temp = n[i]; n[i] = n[j]; n[j] = temp;

}

return i;

}

point_d Cpair(int n[], int low, int high)

{

point_d z1, z2, Min_d={0,0,999999};

int mid, mid_pos, maxs1, mins2;

if ( high-low < 1)

return min_d;

mid = (max(n,low,high) + min(n,low,high))/2; //求数列均值

mid_pos = partition(n,mid,low,high); //按均值分组

z1 = Cpair(n, low, mid_pos); //分别对两组进行递归

z2 = Cpair(n, mid_pos+1, high);

maxs1 = max(n, low, mid_pos);

mins2 = min(n, mid_pos+1, high);

Min_d = z1.d < z2.d ? z1:z2;

if ( mins2 - maxs1 < Min_d.d)

{

Min_d.x = maxs1; Min_d.y = mins2; Min_d.d = mins2-maxs1;

}

return Min_d;

} 习题：

1.求区间第K 大值。

2.子集和问题（两个元素的和）：给定一个由n 个实数构成的集合S 和另一个实数X ，判断S 中是否有两个元素的和等于X 。（提示：利用二分查找）

思考题：棋盘覆盖问题

有一个2k *2k 的方格棋盘，恰有一个方格是黑色的，其他为白色。任务是用包含3个方格的L 型牌覆盖所有白色方格。注：黑色方格不能被覆盖，且任意一个白色方格不能同时被两个或更多牌覆盖。L 型牌的4种旋转方式如下：

分析：当k=1时，选用一块牌就够了；对于2k *2k 的棋盘，可以切分为4块，每块大小为2k-1*2k-1，则对有黑格的那块可以用递归来实现；问题是其他3块呢？可以在切分边界构造黑格，进而用递归解决问题。

四、回溯法

回溯法可以看作是带优化的穷举法。它的基本思想是在一棵含有问题全部可能解的状态空间树上进行深度优先搜索。搜索过程中，每到达一个结点，则判断以该结点为根的子树是否含有问题的解，如果确定其不含问题的解，则退回到上层父结点。回溯法的应用范围：只要能把待求解的问题分成不太多的步骤，每个步骤又只有不太多的选择，都可以考虑应用回溯法。

回溯法求解步骤：

（1） 针对所给问题，定义问题的解空间；

（2） 确定易于搜索的解空间结构（子集树和排列树）；

（3） 以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜

索。 常用的剪枝函数：

（1） 用约束条件在扩展结点处剪去不满足约束的子树； （2） 用限界函数剪去得不到最优解的子树。

例1：经典回溯法解决的问题——四皇后（八皇后）问题。在4×4（8×8）棋盘上放置4（8）个皇后，使她们互不攻击（皇后的攻击范围为同行同列和同对

角线）。

void search(int cur)

{

int i,j;

if(cur==n) tot++;

else for(i=0;i

{

int ok=1;

C[cur]=i;

for(j=0;j

if(C[cur]==C[j]||cur-C[cur]==j-C[j]||cur+C[cur]==j+C[j])

{ ok=0; break;}

If(ok) search(cur+1);

}

}

例2：子集和问题。S是一个由n个正整数组成的集合｛x

1,x

2

,…,x

n

｝,c是

一个正整数。子集和问题是判定是否存在一个S的子集S1，使得其中的元素之和等于c。

说明：cw为当前元素和；r为剩余元素之和；w数组记录集合中各元素值；x 数组描述对应位置的元素是否选中

int backtrack(int i) //i从1开始

{

if (i>n)

{

if (cw==c) return 1;

else return 0;

}

r -= w[i]; //计算剩余大小

if (cw+w[i]<=c) //判断当前和是否小于等于c

{

x[i]=1; //选中第i个元素

cw += w[i];

if (backtrack(i+1)) return 1;

cw -= w[i];

}

if (cw+r >= c) //判断当前和加上剩余元素和是否能满足大于等c

{

x[i] = 0; //不选第i个元素

if ( backtrack(i+1)) return 1;

}

r += w[i];

return 0;

}

注意：上述代码这种递归方式只能找出一个解，不会列出所有可能的解，因为该函数带有返回值，当找到一个解后则层层返回，不会再继续遍历下去。

习题：

1. 有5个砝码，重量为1，3，9，27，81，可以组合成1-121之间的任意整数。对于用户给定的重量，给出砝码方案。

例如：输入5

输出 9-3-1

输入19

输出 27-9+1

2. 马的遍历问题。在Ｎ＊Ｍ的棋盘中，马只能走日字。马从位置(x,y)处出发，把

棋盘的每一格都走一次，且只走一次。找出所有路径。