多机调度最优解问题（回溯法）

最新推荐文章于 2022-04-28 16:36:24 发布
最新推荐文章于 2022-04-28 16:36:24 发布
阅读量757 收藏
点赞数 1
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59593302/article/details/118121997
版权
本文通过一个C语言实现的实例介绍了如何使用回溯法求解多机调度问题，以找到完成所有任务的最短时间。回溯法的本质是穷举所有可能的分配路径并修剪无效路径，通过递归遍历达到最优解。在实验过程中，作者意识到对算法理解的深入程度和C语言的掌握直接影响了实验设计和结果。
摘要由CSDN通过智能技术生成

#include<stdio.h>

int n=9，k=4，best=1000000;

int len[99];

int t[99]={5，10，3，5，12，23，67，1，4，};

int comp(){

int tmp=0;

for(int i=0; i<k; i++)

if(len[i]>tmp)

tmp=len[i];

return tmp;

}

void search(int dep&

最低0.47元/天 解锁文章
m0_59593302
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多机调度问题C++语言解决的源代码
12-27
多机调度问题C++语言解决的源代码，可以看看一下
独立任务最优调度问题（C++）
m0_57443189的博客
11-08 1238
编译环境：Dev-C++ 用动态规划算法设计独立任务最优调度问题解决方案并实现，并分析算法复杂性。
回溯法解最佳调度问题(python实现)
yubaby
12-08 2182
1、问题描述：设有n个任务由k个可并行工作的机器来完成，完成任务i需要时间为ti。试设计一个算法找出完成这个任务的最佳调度，使完成全部任务的时间最早。 2、算法设计：对任意给定的整数n和k，以及完成任务i需要的时间为ti(i=1~n)。计算完成这n个任务的最佳调度。 3、数据输入：由文件input.txt给出输入数据。第1行有2个正整数n和k。第2行的n个正整数是完成n个任务需要的时间。 4...
主定理，动态规划与分治，贪心算法之活动安排问题:之多机调度问题，回溯，0-1背包问题 —— 四种解法解题：
C++
04-18 1054
动态规划与分治： 动态规划与贪心： 分支界限法与回溯的分析： 相同点：二者都是一种在问题的解空间树T上搜索问题解的算法。 贪心算法：https://blog.csdn.net/weixin_41413441/article/details/79195259 0-1背包问题 —— 四种解法解题： ...
多处理机调度（回溯）
learning123456789的博客
12-07 872
引用：https://blog.csdn.net/zhao2018/article/details/82934792 引用：https://wenku.baidu.com/view/b222138a67ec102de3bd8938.html 1.问题描述： 给定n个作业的集合{J1,J2,…,Jn}。每个作业必须先由机器1处理，然后由机器2处理。作业Ji需要机器j的处理时间为tji。对于一个...
批处理作业调度问题 回溯法——C++代码
06-08
6. **剪枝函数**：为了减少搜索空间，可以设计剪枝函数来提前排除那些肯定不能导出最优解的状态。 在给定的C++代码`批处理作业调度 回溯法.cpp`中，作者可能实现了以上这些功能。代码会读取作业信息，然后利用回溯...
图着色问题 回溯法-C语言
08-07
回溯法是一种通过试探性的解决问题并适时撤销选择，以寻找所有可能解或最优解的搜索策略。它常用于解决约束满足问题，如八皇后问题、数独、旅行商问题等，当然也包括图着色问题。 在回溯法解决图着色问题时，通常会...
回溯法的着色问题.zip
03-13
回溯法是一种在解决问题时，通过尝试所有可能的解决方案，并在发现某一步不满足条件时，退回一步重新选择的方法，以此来寻找问题的全局最优解。在这个“着色问题”的场景中，我们可以假设是经典的图着色问题或者棋盘...
01背包问题的回溯法求解
05-26
尽管回溯法不是解决01背包问题的最高效方法（动态规划更优），但它仍然是理解问题本质和算法思想的重要工具，有助于开发解决问题的直觉。通过理解和实践这个算法，可以进一步提升在组合优化问题上的算法设计能力。
回溯法解批处理作业问题
06-12
总之，回溯法在批处理作业调度问题中提供了一种有效的解决方案，它能够系统地探索所有可能的安排，并找到满足约束条件下的最优解。通过理解和掌握这种算法，我们可以解决许多实际的调度问题，优化资源分配，提高工作...
最佳调度问题的回溯算法
02-28
设有n个任务由k个可并行工作的机器来完成，完成任务i需要时间为 。试设计一个算法找出完成这n个任务的最佳调度，使完成全部任务的时间最早。（要求给出调度方案）
最佳调度问题回溯法实现（Java）
01-12
最佳调度问题的回溯算法实现：有n个任务由k个可并行工作的机器完成。完成任务i需要的时间为Ti。找出完成这n个任务的最佳调度，使得完成全部任务的时间最少。用文件导入每个任务所需要的时间Ti。（至少10个任务）使用回溯算法的思想，设计一个解决该问题的算法。设计一个输出界面，输出调度方案。
多机调度问题的贪心算法实现
12-14
多机调度问题的贪心算法实现。示例代码，可直接在VC上运行。
基础算法 —— 调度问题 —— 多机并行调度问题
Alex_McAvoy的博客
07-22 1万+
【概述】 多机调度问题可表达为：n 个工件由 k 个可并行工作的机器加工，完成任务 i 需要的时间为 ti，调度目标是确定这 n 个工件完成的最佳加工顺序，使得完成全部任务的时间最早，其可利用 回溯法 来求解 【问题分析】 问题实质是要从 n 个作业中找出有最小完成时间和的作业调度，因此批处理作业调度问题的解空间是一棵排列树。 开始时，所给的 t[n] 为 n 个作业的完成时间，则相应的排...
算法-回溯法解决最佳调度问题
weixin_33805743的博客
05-17 1427
问题： 假设有n个任务由k个可并行工作的机器来完成。完成任务i需要时间为ti，设计完成这n个任务的最佳调度算法，使得完成全部任务的时间最早。 算法设计： 　　从n个作业中找出有最小完成时间和的作业调度，所以批处理作业调度问题的解空间是一棵排列树。按照回溯法搜索排列树的算法框架，设开始时t=[1,2, ... , n]是所给的n个作业的完成时间，则相应的排...
回溯法实现最佳调度问题
qq_57669041的博客
04-28 2859
使用回溯法实现最佳调度问题
多机调度问题最优解（回溯法）
m0_57319279的博客
06-22 1723
1.设计方案 从n个作业中找出有最小完成时间和的作业调度，所以批处理作业调度问题的解空间是一棵排列树。按照回溯法搜索排列树的算法框架，设开始时t=[1，2，... ，n]是所给的n个作业的完成时间，则相应的排列树由t[1:n]的所有排列构成。 数组len[]用于存储一组空间解，comp()函数用于计算一个完整调度的完成时间，search()函数用来做搜索，best记录相应的当前最佳作业调度完成时间。 当dep>n时，算法搜索至叶子结点，得到一个新的作业调度方案。此时算法适时更新当前最优值和相..
最佳调度问题（回溯法）
ljhsq的博客
05-20 3602
最佳调度问题题目答案参考 题目 假设有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 1
算法：最佳调度问题（回溯法-解法）
热门推荐
bensonrachel的博客
12-30 1万+
最佳调度问题（回溯） 【问题描述】 假设有n个任务由k个可并行工作的机器完成。完成任务i需要的时间为ti。试设计一个算法找出完成这n个任务的最佳调度，使得完成全部任务的时间最早。 【编程任务】 对任意给定的整数n和k，以及完成任务i需要的时间为ti，i=1~n。编程计算完成这n个任务的最佳调度。 【输入样例】 7 3 2 14 4 16 6 5 3 【输出样例】 17
请用c++和回溯法实现多级调度问题最优解
最新发布
04-04
由于多级调度问题是NP完全问题，因此通常使用回溯法来寻找最优解。 首先，我们需要定义问题的数据结构。我们可以使用一个二维数组来表示作业和机器之间的关系，其中第一维表示作业，第二维表示机器。数组中的每个元素表示作业在该机器上的处理时间。 接下来，我们可以使用回溯法来寻找最优解。我们首先定义一个函数，该函数具有以下参数： - 一个当前解决方案，包括分配给每个作业的机器和每个机器上的处理时间。 - 一个已分配的作业列表，表示已经分配了哪些作业。 - 一个未分配的作业列表，表示还没有被分配的作业。 - 一个当前的最优解。 在每个递归步骤中，我们从未分配的作业列表中选择一个作业。对于每个可能的机器，我们计算在该机器上处理该作业所需的时间，并更新当前解决方案。然后，我们递归调用函数，将未分配的作业列表更新为未分配的作业列表减去当前选择的作业。如果当前解决方案比当前最优解更优，则更新最优解。最后，我们将当前解决方案还原为之前的状态，以便继续搜索其他可能的解决方案。 下面是一个示例代码实现： ```c #include <stdio.h> #include <stdlib.h> #define MAX_JOBS 10 #define MAX_MACHINES 10 int jobs[MAX_JOBS][MAX_MACHINES]; // 二维数组表示作业和机器之间的关系 int machines[MAX_MACHINES]; // 每个机器上的处理时间 int best_solution[MAX_JOBS]; // 当前最优解 int best_time = 999999; // 当前最优解的处理时间 void backtrack(int* current_solution, int* assigned_jobs, int* unassigned_jobs, int num_assigned_jobs, int num_unassigned_jobs) { if (num_unassigned_jobs == 0) { // 如果所有作业都已分配，则更新最优解 int current_time = 0; for (int i = 0; i < MAX_MACHINES; i++) { if (machines[i] > current_time) { current_time = machines[i]; } } if (current_time < best_time) { best_time = current_time; for (int i = 0; i < MAX_JOBS; i++) { best_solution[i] = current_solution[i]; } } return; } int next_job = unassigned_jobs[0]; // 选择下一个未分配的作业 int remaining_jobs[MAX_JOBS]; for (int i = 0; i < num_unassigned_jobs - 1; i++) { remaining_jobs[i] = unassigned_jobs[i+1]; } int new_assigned_jobs[MAX_JOBS]; for (int i = 0; i < num_assigned_jobs; i++) { new_assigned_jobs[i] = assigned_jobs[i]; } new_assigned_jobs[num_assigned_jobs] = next_job; for (int i = 0; i < MAX_MACHINES; i++) { if (machines[i] + jobs[next_job][i] < best_time) { // 只考虑比当前最优解更优的解决方案 int new_current_solution[MAX_JOBS]; for (int j = 0; j < MAX_JOBS; j++) { new_current_solution[j] = current_solution[j]; } new_current_solution[next_job] = i; machines[i] += jobs[next_job][i]; backtrack(new_current_solution, new_assigned_jobs, remaining_jobs, num_assigned_jobs+1, num_unassigned_jobs-1); machines[i] -= jobs[next_job][i]; } } } int main() { // 初始化数据 for (int i = 0; i < MAX_JOBS; i++) { for (int j = 0; j < MAX_MACHINES; j++) { jobs[i][j] = rand() % 10 + 1; // 随机生成处理时间 } } int current_solution[MAX_JOBS]; int assigned_jobs[MAX_JOBS]; int unassigned_jobs[MAX_JOBS]; for (int i = 0; i < MAX_JOBS; i++) { current_solution[i] = -1; assigned_jobs[i] = -1; unassigned_jobs[i] = i; } backtrack(current_solution, assigned_jobs, unassigned_jobs, 0, MAX_JOBS); // 输出结果 printf("Best solution: "); for (int i = 0; i < MAX_JOBS; i++) { printf("%d ", best_solution[i]); } printf("\nBest time: %d\n", best_time); return 0; } ``` 在上面的示例代码中，我们使用了一个递归函数`backtrack()`来寻找最优解。在每个递归步骤中，我们选择一个未分配的作业，并为其选择一个机器。然后，我们递归调用函数，将未分配的作业列表更新为未分配的作业减去当前选择的作业。如果当前解决方案比当前最优解更优，则更新最优解。最后，我们将当前解决方案还原为之前的状态，以便继续搜索其他可能的解决方案。 在主函数中，我们首先初始化数据，然后调用`backtrack()`函数来寻找最优解。最后，我们输出最优解和处理时间。 需要注意的是，由于多级调度问题是NP完全问题，因此该算法的时间复杂度非常高，通常只适用于小规模问题。对于大规模问题，通常需要使用其他算法，如启发式搜索算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值