回溯法——最佳调度问题

一、题目要求

设有n个任务由k个可并行工作的机器来完成，完成任务i需要时间为。试设计一个算法找出完成这n个任务的最佳调度，使完成全部任务的时间最早。

二 、算法设计与分析：

该算法可抽象为子集树回溯算法，针对特定的任务数和机器数定义解空间，对于n个任务和k个机器，

解编码：（X1，X2，。。。，Xn），Xi表示给任务i分配的机器编号；

解空间：{（X1，X2，。。。，Xn）| Xi属于S，i=1到n}，S={1,2，。。。，k}

三、算法实现

#define NUM_TASK 10
#define NUM_MAC 3
#include <iostream>
#include <climits>
using namespace std;
void output(int x[]);
void BackTrack(int task);
int getTime(int time_mac[]);
void output_assign(int best_x[]);

//所有数组下标从1开始
int x[NUM_TASK + 1];//x[task]表示给任务task分配机器x[task]
int best_x[NUM_TASK+1];//存储最优分配方案
int min_t=INT_MAX;//执行任务所需的最小时间
int t[NUM_TASK + 1] = { 0,1,7,4,0,9,4,8,8,2,4 };//每个任务所需时间
//int t[NUM_TASK + 1] = { 0,1,7,4 };//每个任务所需时间
int time_mac[NUM_MAC + 1] = {0};//每个机器运行结束的时间

int main() {
	BackTrack(1);

	cout << "各个任务执行时间依次为：" << endl;
	for (int i = 1; i <= NUM_TASK; i++) {
		cout << t[i] << " ";
	}
	cout << endl;
	cout << "所需要的最小时间为："<<min_t << endl;
	//output(best_x);
	output_assign(best_x);
	return 0;
}
void BackTrack(int task) {

	if (task > NUM_TASK) {
		
		int cur_time = getTime(time_mac);//当前已分配任务的完成时间
		/*输出所有分配情况，以及对应的时间*/
		//output(x);
		//cout << "time=" << cur_time <<endl;
		
		if (cur_time < min_t) { //剪枝
			min_t = cur_time;
			for (int i = 1; i <=NUM_TASK; i++) {
				best_x[i] = x[i];
			}
		}
	}
	else{
		for (int i = 1; i <= NUM_MAC; i++) {
			x[task] = i;
			time_mac[i] += t[task];
			if(time_mac[i]<min_t)
				BackTrack(task+1);
			time_mac[i] -= t[task];
		}
	}
}

void output(int x[]) {
	for (int i = 1; i <= NUM_TASK; i++) {
		cout << x[i]<< " ";
	}
}

int getTime(int time_mac[]) {
	int max_time=time_mac[1];
	for (int i = 2; i <= NUM_MAC; i++) {
		if (time_mac[i] > max_time) {
			max_time = time_mac[i];
		}
	}
	return max_time;
}

void output_assign(int best_x[]) {
	for (int i = 1; i <= NUM_TASK; i++) {
		cout << "任务" << i << "分配给机器" << best_x[i] << endl;
	}
}

四、结果分析和总结

3.1 任务数为10，机器数为5，运行结果如下：

3.2 任务数为10，机器数为3，运行结果如下：

3.3 分析总结

本实验采用子集树回归算法完成最佳调度问题，在不剪枝的情况下，由该问题解空间可知该算法时间复杂度为n！，当任务数为10的时候需要进行3628800次搜索，效率极低，采用剪枝操作后算法效率得到明显提升。