回溯法（2）
二、批处理作业调度
问题表述：给定n个作业的集合{J1,J2,…,Jn}。每个作业必须先由机器1处理，然后由机器2处理。作业Ji需要机器j的处理时间为tji。对于一个确定的作业调度，设Fji是作业i在机器j上完成处理的时间。所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。
批处理作业调度问题要求对于给定的n个作业，制定最佳作业调度方案，使其完成时间和达到最小。
显然，1,3,2是最佳调度方案。
解空间：排列树（将作业顺序进行全排列，分别算出各种情况的完成时间和，取最佳调度方案）
实现：
/* 主题：批处理作业调度算法
* 作者：chinazhangjie
* 邮箱：chinajiezhang@gmail.com
* 开发语言：C++
* 开发环境：Mircosoft Virsual Studio 2008
* 时间: 2010.10.24
*/
#include <iostream>
#include <vector>
using namespace std;
class flowshop
{
public:
flowshop(vector<vector<int> >& rhs) {
task_count = rhs.size() ;
each_t = rhs ;
best_t.resize (task_count) ;
machine2_t.resize (task_count,0) ;
machine1_t = 0 ;
total_t = 0 ;
best_total_t = 0 ;
current_t.resize (task_count,0) ;
for (int i = 0 ;i < task_count; ++ i) {
current_t[i] = i; // 为了实现全排列
}
}
void backtrack () {
__backtrack (0);
// 显示最佳调度方案和最优完成时间和
cout << "the best flowshop scheme is : ";
copy (best_t.begin(),best_t.end(),ostream_iterator<int> (cout, " "));
cout << endl;
cout << "the best total time is : " << best_total_t << endl;
}
private:
void __backtrack (int i) {
if (i >= task_count) {
if (total_t < best_total_t || best_total_t == 0) {
// 存储当前最优调度方式
copy (current_t.begin(),current_t.end(),best_t.begin()) ;
best_total_t = total_t;
}
return ;
}
for (int j = i; j < task_count; ++ j) {
// 机器1上结束的时间
machine1_t += each_t[current_t[j]][0] ;
if (i == 0) {
machine2_t[i] = machine1_t + each_t[current_t[j]][1] ;
}
else {
// 机器2上结束的时间
machine2_t[i] =
((machine2_t[i - 1] > machine1_t) ? machine2_t[i - 1] : machine1_t)
+ each_t[current_t[j]][1] ;
}
total_t += machine2_t[i];
// 剪枝
if (total_t < best_total_t || best_total_t == 0) {
// 全排列
swap (current_t[i],current_t[j]) ;
__backtrack (i + 1) ;
swap (current_t[i],current_t[j]) ;
}
machine1_t -= each_t[current_t[j]][0] ;
total_t -= machine2_t[i] ;
}
}
public :
int task_count ; // 作业数
vector<vector<int> > each_t ; // 各作业所需的处理时间
vector<int> current_t ; // 当前作业调度
vector<int> best_t ; // 当前最优时间调度
vector<int> machine2_t ; // 机器2完成处理的时间
int machine1_t ; // 机器1完成处理的时间
int total_t ; // 完成时间和
int best_total_t ; // 当前最优完成时间和
};
int main()
{
// const int task_count = 4;
const int task_count = 3 ;
vector<vector<int> > each_t(task_count) ;
for (int i = 0;i < task_count; ++ i) {
each_t[i].resize (2) ;
}
each_t[0][0] = 2 ;
each_t[0][1] = 1 ;
each_t[1][0] = 3 ;
each_t[1][1] = 1 ;
each_t[2][0] = 2 ;
each_t[2][1] = 3 ;
// each_t[3][0] = 1 ;
// each_t[3][1] = 1 ;
flowshop fs(each_t) ;
fs.backtrack () ;
}
三、n后问题
问题表述：在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。n后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。求不同的解的个数。
解向量：(x1, x2, … , xn)
显约束：xi = 1,2, … ,n
隐约束：
1)不同列：xi != xj
2)不处于同一正、反对角线：|i-j| != |x(i)-x(j)|
解空间：满N叉树
实现：
/* 主题：n后问题
* 作者：chinazhangjie
* 邮箱：chinajiezhang@gmail.com
* 开发语言：C++
* 开发环境：Mircosoft Virsual Studio 2008
* 时间: 2010.10.24
*/
#include <iostream>
#include <vector>
using namespace std;
class queen
{
// 皇后在棋盘上的位置
struct q_place {
int x;
int y;
q_place ()
: x(0),y(0)
{}
};
public:
queen(int qc)
: q_count (qc), sum_solution (0) {
curr_solution.resize (q_count);
}
void backtrack () {
__backtrack (0);
}
private:
void __backtrack (int t) {
if (t >= q_count) {
// 找到一个解决方案
++ sum_solution ;
for (size_t i = 0;i < curr_solution.size(); ++ i) {
cout << "x = " << curr_solution[i].x
<< " y = " << curr_solution[i].y << endl;
}
cout << "sum_solution = " << sum_solution << endl;
}
else {
for (int i = 0;i < q_count; ++ i) {
curr_solution[t].x = i;
curr_solution[t].y = t;
if (__place(t)) {
__backtrack (t + 1);
}
}
}
}
// 判断第k个皇后的位置是否与前面的皇后相冲突
bool __place (int k) {
for (int i = 0; i < k; ++ i) {
if ((abs(curr_solution[i].x - curr_solution[k].x)
== abs(curr_solution[i].y - curr_solution[k].y))
|| curr_solution[i].x == curr_solution[k].x) {
return false;
}
}
return true;
}
private:
vector<q_place> curr_solution; // 当前解决方案
const int q_count; // 皇后个数
int sum_solution; // 当前找到的解决方案的个数
};
int main()
{
queen q(5);
q.backtrack ();
return 0;
}
参考资料 《算法设计与分析》王晓东编著
授课教师 张阳教授
