最佳调度问题(回溯法)

最佳调度问题

题目

假设有n(n<=20)个任务由k(k<=20)个可并行工作的机器完成。完成任务i需要的时间为ti。 试设计一个算法,对任意给定的整数n和k,以及完成任务i 需要的时间为ti ,i=1~n。计算完成这n个任务的最佳调度,使得完成全部任务的时间最早。

输入格式:
输入数据的第一行有2 个正整数n和k。第2 行的n个正整数是完成n个任务需要的时间。

输出格式:
将计算出的完成全部任务的最早时间输出到屏幕。

输入样例:
在这里给出一组输入。例如:

7 3
2 14 4 16 6 5 3

输出样例:
在这里给出相应的输出。例如:

17

答案

#include<iostream>
#include<algorithm>
using namespace std;
int n,k,t[99],ans[99],min_time=0x3f3f3f3f;
void dfs(int level)
{
	if(level==n)
	{
		int tmp=*max_element(ans,ans+n);
		if(tmp<min_time) min_time=tmp;
		return;
	}
	for(int i=0;i<k;i++)
	{
		ans[i]+=t[level];
		if(ans[i]<min_time) dfs(level+1);
		ans[i]-=t[level];
	}
}
int main()
{
	cin>>n>>k;
	fill(ans,ans+99,0);
	for(int i=0;i<n;i++)
	cin>>t[i];
	dfs(0);
	cout<<min_time<<endl;
}

参考

算法-回溯法解决最佳调度问题

这篇文章中有思路讲解,大家可以去看一下,我对于代码做了一定的优化

  • 4
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
回溯法可以用于解决批处理调度问题。批处理调度问题是指有一批任务需要在有限的时间内完成,每个任务都有一个预计的执行时间和一个截止时间,任务需要按照一定的顺序执行,以最小化任务的延迟时间。 以下是使用回溯法解决批处理调度问题的基本步骤: 1. 定义状态空间:将所有可能的任务排列顺序看作一个状态空间,每个状态代表一种任务的排列顺序。 2. 定义状态转移函数:根据当前任务的排列顺序,生成所有可能的下一个状态。 3. 定义目标函数:根据当前任务的排列顺序,计算当前任务的延迟时间。 4. 定义剪枝函数:根据当前任务的排列顺序和已经执行的任务时间,判断当前任务是否可以继续执行。 5. 进行回溯搜索:从初始状态开始搜索状态空间,根据目标函数和剪枝函数剪枝无效搜索路径,直到找到最优解或搜索完整个状态空间。 下面是一个简单的Java代码实现: ```java public class BatchScheduler { private int[] tasks; private int[] deadlines; private int[] durations; private int[] solution; private int minDelay; public BatchScheduler(int[] tasks, int[] deadlines, int[] durations) { this.tasks = tasks; this.deadlines = deadlines; this.durations = durations; this.solution = new int[tasks.length]; this.minDelay = Integer.MAX_VALUE; } public int[] solve() { backtrack(0, 0, 0); return solution; } private void backtrack(int step, int time, int delay) { if (step == tasks.length) { if (delay < minDelay) { minDelay = delay; System.arraycopy(tasks, 0, solution, 0, tasks.length); } return; } for (int i = step; i < tasks.length; i++) { swap(tasks, step, i); swap(deadlines, step, i); swap(durations, step, i); int newTime = time + durations[step]; int newDelay = Math.max(0, newTime - deadlines[step]); if (time <= deadlines[step] && newTime <= deadlines[step] && delay + newDelay < minDelay) { backtrack(step + 1, newTime, delay + newDelay); } swap(tasks, step, i); swap(deadlines, step, i); swap(durations, step, i); } } private void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } } ``` 在这个实现中,`tasks`数组表示所有任务的编号,`deadlines`数组表示每个任务的截止时间,`durations`数组表示每个任务的执行时间,`solution`数组表示最优任务排列顺序,`minDelay`变量表示最小延迟时间。 回溯搜索函数`backtrack`的参数包括当前搜索步数`step`,已经执行的任务时间`time`,已经产生的延迟时间`delay`。在每一步搜索中,先交换当前任务与之后的任务顺序,然后计算加入当前任务后的新时间和新延迟时间。如果新时间和新延迟时间都符合要求,就递归搜索下一步。最后,回溯到上一步时还要恢复当前任务的顺序。 使用该实现的示例代码如下: ```java int[] tasks = {1, 2, 3, 4}; int[] deadlines = {4, 2, 4, 3}; int[] durations = {3, 1, 2, 1}; BatchScheduler scheduler = new BatchScheduler(tasks, deadlines, durations); int[] solution = scheduler.solve(); System.out.println(Arrays.toString(solution)); // 输出 [2, 4, 3, 1] ``` 这个示例中,有4个任务需要在不同的截止时间内完成,每个任务的执行时间也不同。使用回溯法求解得到最优的任务排列顺序是 `[2, 4, 3, 1]`,可以使得任务的延迟时间最小。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值