好,顶
原文地址:(转)回溯法-算法框架及基础
作者:jinyang6655
转自http://lilongfei1030.blog.163.com/blog/static/8601528200872081318804/
回溯法其实也是一种搜索算法,它可以方便的搜索解空间。
回溯法解题通常可以从以下三步入手:
1、针对问题,定义解空间
2、确定易于搜索的解空间结构
3、以深度优先的方式搜索解空间,并在搜索的过程中进行剪枝
回溯法通常在解空间树上进行搜索,而解空间树通常有子集树和排列树。
针对这两个问题,算法的框架基本如下:
用回溯法搜索子集合树的一般框架:
其中f(n,t),g(n,t)表示当前扩展结点处未搜索过的子树的起始标号和终止标号,
h(i)表示当前扩展节点处,x[t]第i个可选值。constraint(t)和bound(t)是当前
扩展结点处的约束函数和限界函数。constraint(t)返回true时,在当前扩展结点
x[1:t]取值满足约束条件,否则不满足约束条件,可减去相应的子树。bound(t)返
回的值为true时,在当前扩展结点x[1:x]处取值未使目标函数越界,还需要由backtrack(t+1)
对其相应的子树进一步搜索。
用回溯法其实质上是提供了搜索解空间的方法,当我们能够搜遍解空间时,
显然我们就能够找到最优的或者满足条件的解。这便是可行性的问题, 而效率可以
通过剪枝函数来降低。但事实上一旦解空间的结构确定了,很大程度上时间复杂度
也就确定了,所以选择易于搜索的解空间很重要。
下面我们看看两个最简单的回溯问题,他们也代表了两种搜索类型的问题:子集合问题和
排列问题。
第一个问题:
求集合s的所有子集(不包括空集),我们可以按照第一个框架来写代码:
下面我们看第二个问题:排列的问题,求一个集合元素的全排列。
我们可以按照第二个框架写出代码:
这两个问题很有代表性,事实上有许多问题都是从这两个问题演变而来的。第一个问题,它穷举了所有问题的子集,这是所有第一种类型的基础,第二个问题,它给出了穷举所有排列的方法,这是所有的第二种类型的问题的基础。理解这两个问题,是回溯算法的基础.
下面看看一个较简单的问题:
整数集合s和一个整数sum,求集合s的所有子集su,使得su的元素之和为sum。
这个问题很显然是个子集合问题,我们很容易就可以把第一段代码修改成这个问题的代码:
回溯法解题通常可以从以下三步入手:
1、针对问题,定义解空间
2、确定易于搜索的解空间结构
3、以深度优先的方式搜索解空间,并在搜索的过程中进行剪枝
回溯法通常在解空间树上进行搜索,而解空间树通常有子集树和排列树。
针对这两个问题,算法的框架基本如下:
用回溯法搜索子集合树的一般框架:
- void
backtrack(int t){ -
if(t > n) output(x); -
else{ -
for(int i = f(n,t); i <= g(n,t);i++){ -
x[t] = h(i); -
if(constraint(t) && bound(t)) backtrack(t+1); -
} -
} - }
- 用回溯法搜索排列树的算法框架:
- void
backtrack(int t){ -
if(t > n) output(x); -
else{ -
for(int i = f(n,t); i <= g(n,t);i++){ -
swap(x[t],x[i]); -
if(constraint(t) && bound(t)) backtrack(t+1); -
swap(x[t],x[i]); -
} -
} - }
void backtrack(int t){ if(t > n) output(x); else{ for(int i = f(n,t); i <= g(n,t);i++){ swap(x[t],x[i]); if(constraint(t) && bound(t)) backtrack(t+1); swap(x[t],x[i]); } } }
其中f(n,t),g(n,t)表示当前扩展结点处未搜索过的子树的起始标号和终止标号,
h(i)表示当前扩展节点处,x[t]第i个可选值。constraint(t)和bound(t)是当前
扩展结点处的约束函数和限界函数。constraint(t)返回true时,在当前扩展结点
x[1:t]取值满足约束条件,否则不满足约束条件,可减去相应的子树。bound(t)返
回的值为true时,在当前扩展结点x[1:x]处取值未使目标函数越界,还需要由backtrack(t+1)
对其相应的子树进一步搜索。
用回溯法其实质上是提供了搜索解空间的方法,当我们能够搜遍解空间时,
显然我们就能够找到最优的或者满足条件的解。这便是可行性的问题, 而效率可以
通过剪枝函数来降低。但事实上一旦解空间的结构确定了,很大程度上时间复杂度
也就确定了,所以选择易于搜索的解空间很重要。
下面我们看看两个最简单的回溯问题,他们也代表了两种搜索类型的问题:子集合问题和
排列问题。
第一个问题:
求集合s的所有子集(不包括空集),我们可以按照第一个框架来写代码:
- #include
- using
namespace std; -
- int
s[3] = {1,3,6}; - int
x[3]; - int
N = 3; - void
print(){ -
for(int j = 0; j < N; j++) -
if(x[j] == 1) -
cout << s[j] << " "; -
cout << endl; - }
-
- void
subset(int i){ -
if(i >= N){ -
print(); -
return; -
} -
-
x[i] = 1;//搜索右子树 -
subset(i+1); -
x[i] = 0;//搜索左子树 -
subset(i+1); - }
-
- int
main(){ -
subset(0); -
return 0; - }
#include using namespace std; int s[3] = {1,3,6}; int x[3]; int N = 3; void print(){ for(int j = 0; j < N; j++) if(x[j] == 1) cout << s[j] << " "; cout << endl; } void subset(int i){ if(i >= N){ print(); return; } x[i] = 1;//搜索右子树 subset(i+1); x[i] = 0;//搜索左子树 subset(i+1); } int main(){ subset(0); return 0; }
下面我们看第二个问题:排列的问题,求一个集合元素的全排列。
我们可以按照第二个框架写出代码:
- #include
- using
namespace std; -
- int
a[4] = {1,2,3,4}; - const
int N = 4; -
- void
print(){ -
for(int i = 0; i < N; i++) -
cout << a[i] << " "; -
cout << endl; - }
-
- void
swap(int *a,int i,int j){ -
int temp; -
temp = a[i]; -
a[i] = a[j]; -
a[j] = temp; - }
-
- void
backtrack(int i){ -
if(i >= N){ -
print(); -
} -
for(int j = i; j < N; j++){ -
swap(a,i,j); -
backtrack(i+1); -
swap(a,i,j); -
} - }
-
- int
main(){ -
backtrack(0); -
return 0; - }
#include using namespace std; int a[4] = {1,2,3,4}; const int N = 4; void print(){ for(int i = 0; i < N; i++) cout << a[i] << " "; cout << endl; } void swap(int *a,int i,int j){ int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } void backtrack(int i){ if(i >= N){ print(); } for(int j = i; j < N; j++){ swap(a,i,j); backtrack(i+1); swap(a,i,j); } } int main(){ backtrack(0); return 0; }
这两个问题很有代表性,事实上有许多问题都是从这两个问题演变而来的。第一个问题,它穷举了所有问题的子集,这是所有第一种类型的基础,第二个问题,它给出了穷举所有排列的方法,这是所有的第二种类型的问题的基础。理解这两个问题,是回溯算法的基础.
下面看看一个较简单的问题:
整数集合s和一个整数sum,求集合s的所有子集su,使得su的元素之和为sum。
这个问题很显然是个子集合问题,我们很容易就可以把第一段代码修改成这个问题的代码:
- int
sum = 10; - int
r = 0; - int
s[5] = {1,3,6,4,2}; - int
x[5]; - int
N = 5; -
- void
print(){ -
for(int j = 0; j < N; j++) -
if(x[j] == 1) -
cout << s[j] << " "; -
cout << endl; - }
- void
sumSet(int i){ -
if(i >= N){ -
if(sum == r) print(); -
return; -
} -
if(r < sum){//搜索右子树 -
r += s[i]; -
x[i] = 1; -
sumSet(i+1); -
r -= s[i]; -
} -
x[i] = 0;//搜索左子树 -
sumSet(i+1); - }
-
- int
main(){ -
sumSet(0); -
return 0; - }
八皇后问题
八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出:在8X8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上.
问题分析:
第一步 定义问题的解空间
这个问题解空间就是8个皇后在棋盘中的位置.
第二步 定义解空间的结构
可以使用8*8的数组,但由于任意两个皇后都不能在同行,我们可以用数组下标表示
行,数组的值来表示皇后放的列,故可以简化为一个以维数组x[9]。
第三步 以深度优先的方式搜索解空间,并在搜索过程使用剪枝函数来剪枝
根据条件:x[i] == x[k]判断处于同一列
abs(k-i) == abs(x[k]-x[i]判断是否处于同一斜线
我们很容易写出剪枝函数:
问题分析:
第一步 定义问题的解空间
这个问题解空间就是8个皇后在棋盘中的位置.
第二步 定义解空间的结构
可以使用8*8的数组,但由于任意两个皇后都不能在同行,我们可以用数组下标表示
行,数组的值来表示皇后放的列,故可以简化为一个以维数组x[9]。
第三步 以深度优先的方式搜索解空间,并在搜索过程使用剪枝函数来剪枝
根据条件:x[i] == x[k]判断处于同一列
abs(k-i) == abs(x[k]-x[i]判断是否处于同一斜线
我们很容易写出剪枝函数:
-
//判断处于同一列或同一斜线 -
if(x[i] == x[k] || abs(k-i) == abs(x[k]-x[i])) return false; -
} -
return true; - }
bool canPlace(int k){ for(int i = 1; i < k; i++){ //判断处于同一列或同一斜线 if(x[i] == x[k] || abs(k-i) == abs(x[k]-x[i])) return false; } return true; }
然后我们按照回溯框架一,很容易写出8皇后的回溯代码:
- void
queen(int i){ -
if(i > 8){ -
print(); -
return; -
} -
for(int j = 1; j <= 8; j++){ -
x[i] = j;//记录所放的列 -
if(canPlace(i)) queen(i+1); -
} - }
void queen(int i){ if(i > 8){ print(); return; } for(int j = 1; j <= 8; j++){ x[i] = j;//记录所放的列 if(canPlace(i)) queen(i+1); } }
整个代码:
- #include<iostream>
- #include<cmath>
- using
namespace std; -
- int
x[9]; - void
print(){ -
for(int i = 1; i <= 8; i++) -
cout << x[i] << " "; -
cout << endl; - }
-
- bool
canPlace(int k){ -
for(int i = 1; i < k; i++){ -
//判断处于同一列或同一斜线 -
if(x[i] == x[k] || abs(k-i) == abs(x[k]-x[i])) -
return false; -
} -
return true; - }
-
- void
queen(int i){ -
if(i > 8){ -
print(); -
return; -
} -
for(int j = 1; j <= 8; j++){ -
x[i] = j; -
if(canPlace(i)) queen(i+1); -
} - }
-
- int
main(){ -
queen(1); -
return 0; - }
0-1背包问题
0-1背包问题:给定n种物品和一背包.物品i的重量是wi, 其价值为ui,背包的容量为C.
问如何选择装入背包的物品,使得装入背包中物品的总价值最大?
分析:
0-1背包是子集合选取问题,一般情况下0-1背包是个NP问题.
第一步 确定解空间:装入哪几种物品
第二步 确定易于搜索的解空间结构:
可以用数组p,w分别表示各个物品价值和重量。
用数组x记录,是否选种物品
第三步 以深度优先的方式搜索解空间,并在搜索的过程中剪枝
我们同样可以使用子集合问题的框架来写我们的代码,和前面子集和数问题相差无几。
问如何选择装入背包的物品,使得装入背包中物品的总价值最大?
分析:
0-1背包是子集合选取问题,一般情况下0-1背包是个NP问题.
第一步 确定解空间:装入哪几种物品
第二步 确定易于搜索的解空间结构:
可以用数组p,w分别表示各个物品价值和重量。
用数组x记录,是否选种物品
第三步 以深度优先的方式搜索解空间,并在搜索的过程中剪枝
我们同样可以使用子集合问题的框架来写我们的代码,和前面子集和数问题相差无几。
- using
namespace std; -
- class
Knapsack{ - public:
-
Knapsack(double *pp,double *ww,int nn,double cc){ -
p = pp; -
w = ww; -
n = nn; -
c = cc; -
cw = 0; -
cp = 0; -
bestp = 0; -
x = new int[n]; -
cx = new int[n]; -
} -
-
void knapsack(){ -
backtrack(0); -
} -
-
void backtrack(int i){//回溯法 -
if(i > n){ -
if(cp > bestp){ -
bestp = cp; -
for(int i = 0; i < n; i++) -
x[i] = cx[i]; -
} -
return; -
} -
-
if(cw + w[i] <= c){//搜索右子树 -
cw += w[i]; -
cp += p[i]; -
cx[i] = 1; -
backtrack(i+1); -
cw -= w[i]; -
cp -= p[i]; -
} -
cx[i] = 0; -
backtrack(i+1);//搜索左子树 -
} -
-
void printResult(){ -
cout << "可以装入的最大价值为:" << bestp << endl; -
cout << "装入的物品依次为:"; -
for(int i = 0; i < n; i++){ -
if(x[i] == 1) -
cout << i+1 << " "; -
} -
cout << endl; -
} -
- private:
-
double *p,*w; -
int n; -
double c; -
double bestp,cp,cw;//最大价值,当前价值,当前重量 -
int *x,*cx; - };
-
- int
main(){ - double
p[4] = {9,10,7,4},w[4] = {3,5,2,1}; -
Knapsack ks = Knapsack(p,w,4,7); -
ks.knapsack(); - ks.printResult();
- return
0; - }
注: