回溯法实现最佳调度问题

回溯法实现最佳调度问题

实验目的

  1. 掌握回溯法的深度优先搜索策略、剪枝策略及基本概念
  2. 掌握两种基本的解空间树:子集树和排列树
  3. 掌握装载问题、0-1背包问题、n后问题、旅行售货员问题。
  4. 掌握回溯法的效率分析。

实训内容

  1. 算法设计题:使用回溯法实现最佳调度问题(P162,5-15) (需要文字描述解空间树的组织和限界函数的设计)。

 分析:

我们知道回溯法其实是穷举法加剪枝函数,我们的函数用到递归,层层返回。一共七层,每层的除去叶子节点都有三个孩子

每搜索到叶子节点就更新一次best值(小于best则更新)(初值为一个较大的数),是用一次搜索结束后三个机器中花费时间最长的机器的所用时间作为此次分配的所用时间。

解空间树的组织:

       问题的解空间描述了nk种可能性,如果k=3,那么每件任务都有3中选择,即解空间中每个结点有k个分支,称为k叉树。

限界函数的设计:

       如果时间上界大于当前搜索到的best,那么继续搜索不可能得到一个更优解,所以可以剪去。反之,则继续搜索

t[deep] + x[i] <= best

代码:

py:

# 打开input.txt文件
fr = open("input.txt", "r+")
temp = (fr.readline())
# temp返回str,注意k应该为temp[2]
n = int(temp[0])
k = int(temp[2])
t = fr.readline().split()
best = 100000
# 机器所用时间
x = [0] * (k + 1)


def __task(deep, y):
    # 修改best全局变量
    global best
    if y > best: return
    if deep >= n:
        temp = 0
        # 这个循环为了获得k个机器中用时最长作为总时长
        for i in range(1, k + 1):
            if x[i] > temp:
                temp = x[i]
        # 这里为了更新best的值从而得到所有情况中的最优解
        if temp < best:
            best = temp
    else:
        for i in range(1, k + 1):
            if int(t[deep]) + x[i] <= best:
                x[i] += int(t[deep])
                __task(deep + 1, max(y, x[i]))
                x[i] -= int(t[deep])


__task(0, 0)
print(best)
fw = open("output.txt", "w+")
fw.write(str(best))

c ++:

#include<bits/stdc++.h>
using namespace std;
int n,k;
int x[100];//机器
int x1[100];//作业
int maxnum=1000000;

void task(int level)
{
    if(level>n){
     int temp=0;
     for(int i=1;i<=k;i++){
        if(x[i]>temp){
            temp=x[i];
        }
     }
     if(temp<maxnum){
        maxnum=temp;
     }
    }
    else{
        for(int i=1;i<=k;i++){
            x[i]+=x1[level];
            task(level+1);
            x[i]-=x1[level];
        }
    }
}
int main()
{
    cin >> n;
    cin >> k;
    for(int i=1;i<=n;i++){
        cin >>x1[i];
    }
    task(1);
    cout << maxnum;
    return 0;
}

回溯法和分支限界法的区别:

    共同点:一种在问题的解空间树上搜索问题解的算法。

    不同点:

  1. 求解目标不同,回溯法的目标是找出解空间树满足约束条件的所有解,而分支限界法的求解目标是尽快地找出满足约束条件的一个解;
  2. 搜索方法不同,回溯法采用深度优先方法搜索解空间,而分支限界法一般采用广度优先或以最小消耗优先的方式搜索解空间树;
  3. 对扩展结点的扩展方式不同,回溯法中,如果当前的扩展结点不能够再向纵深方向移动,则当前扩展结点就成为死结点,此时应回溯到最近一个活结点处,并使此活结点成为扩展结点。分支限界法中,每一次活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点,就一次性产生其所有儿子结点
  4. 存储空间的要求不同,分支限界法的存储空间比回溯法大得多,当内存容量有限时,回溯法成功的可能性更大。

  • 6
    点赞
  • 47
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
由于多级调度问题是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、付费专栏及课程。

余额充值