教室借用-贪婪算法

詹小友

已于 2023-05-18 01:14:56 修改

阅读量530

点赞数 2

文章标签：算法

于 2023-05-18 01:10:08 首次发布

本文链接：https://blog.csdn.net/weixin_62268437/article/details/130736796

版权

问题1：

假设你有一个教室（只有一个教室），你有几个来自讲师的使用教室的请求。应用间隔调度问题来安排尽可能多的请求，以优化教室的使用。

最早开始时间

最早开始时间（Earliest Start Time，简称EST）是一种贪心思想的解决方案，其基本思想是将所有请求按照开始时间从小到大排序，然后选择开始时间最早的请求进行安排。

具体来说，对于给定的讲师请求集合，首先将它们按照开始时间从小到大排序，然后从第一个请求开始处理，依次处理后续的请求。处理时，如果当前请求的开始时间晚于前面已安排的请求的结束时间，则可以选择该请求，并将该请求的结束时间设为下一次安排的起始时间。

这个过程中，每次选择开始时间最早的请求，可以使得后续可用的空闲时间段最长，从而最大限度地利用教室资源。

因此，在最早开始时间方法的代码实现中，我们可以使用sort函数对请求按照开始时间进行排序，然后从第一个请求开始处理，依次判断每个请求与前面所有已安排的请求的关系，选择开始时间最早且不与前面已安排的请求冲突的请求进行安排。

#include <iostream>
#include <algorithm>   //使用sort函数
using namespace std;

//定义一个结构体表示讲师对教室的请求
struct Request{
    int start_time;   //开始时间
    int end_time;     //结束时间
    string slide_no;     //编号
};

//定义比较函数，用于sort函数中进行按照开始时间排序
bool cmp_start_time(Request a, Request b){
    return a.start_time < b.start_time;
}

int main(){
    //输入讲师们的请求
    const int n = 8;   //假设有8个讲师的请求
    Request requests[n] = {{0,6,"a"}, {1,4,"b"}, {3,5,"c"}, {3,8,"d"}, {4,7,"e"}, {5,9,"f"},{6,10,"g"},{8,11,"h"},};

    //按照开始时间排序
    sort(requests, requests+n, cmp_start_time);

    //使用间隔调度来安排请求
    cout << "按照最早开始时间进行排列的安排方法为：" << endl;
    int current_end_time = requests[0].end_time;
    cout << "安排 " << requests[0].slide_no << " 讲师请求" << endl;
    for(int i=1;i<n;i++){
        if(requests[i].start_time >= current_end_time){
            current_end_time = requests[i].end_time;
            cout << "安排 " << requests[i].slide_no << " 讲师请求" << endl;
        }
    }

    return 0;
}

运行截图

最早完成时间方法

最早完成时间（Earliest Finish Time，简称EFT）也是一种贪心思想的解决方案，其基本思想是将所有请求按照结束时间从小到大排序，然后选择结束时间最早的请求进行安排。

具体来说，对于给定的讲师请求集合，首先将它们按照结束时间从小到大排序，然后从第一个请求开始处理，依次处理后续的请求。处理时，如果当前请求的开始时间晚于前面已安排的请求的结束时间，则可以选择该请求，并将该请求的结束时间设为下一次安排的起始时间。

这个过程中，每次选择结束时间最早的请求，可以使得后续可用的空闲时间段最长，从而最大限度地利用教室资源。

因此，在最早完成时间方法的代码实现中，我们可以使用sort函数对请求按照结束时间进行排序，然后从第一个请求开始处理，依次判断每个请求与前面所有已安排的请求的关系，选择结束时间最早且不与前面已安排的请求冲突的请求进行安排。

#include <iostream>
#include <algorithm>   //使用sort函数
using namespace std;
 
//定义一个结构体表示讲师对教室的请求
struct Request{
    int start_time;   //开始时间
    int end_time;     //结束时间
    string slide_no;     //讲师编号
};
 
//定义比较函数，用于sort函数中进行按照结束时间排序
bool cmp_end_time(Request a, Request b){
    return a.end_time < b.end_time;
}
 
int main(){
    //输入讲师们的请求
    const int n = 8;   //假设有8个讲师的请求
    Request requests[n] = {{0,6,"a"}, {1,4,"b"}, {3,5,"c"}, {3,8,"d"}, {4,7,"e"}, {5,9,"f"},{6,10,"g"},{8,11,"h"},};
 
    //按照结束时间排序
    sort(requests, requests+n, cmp_end_time);
 
    //使用间隔调度来安排请求
    cout << "按照最早完成时间进行排列的安排方法为：" << endl;
    int current_end_time = requests[0].end_time;
    cout << "安排 " << requests[0].slide_no << " 讲师请求" << endl;
    for(int i=1;i<n;i++){
        if(requests[i].start_time >= current_end_time){
            current_end_time = requests[i].end_time;
            cout << "安排 " << requests[i].slide_no << " 讲师请求" << endl;
        }
    }
 
    return 0;
}

运行截图

问题2

假设你有4个教室，你有几个讲师要求使用教室。应用区间划分问题来安排尽可能多的请求，以优化教室的使用。

最短的时间间隔

首先定义一个结构体Request，用于记录每个请求的信息，包括教师姓名、开始时间、结束时间和教室编号。其中，开始时间和结束时间以字符串形式存储，教室编号为整型。
定义一个比较函数cmp()，用于按照请求的开始时间从小到大排序。比较函数中，将开始时间转换为分钟数进行比较，方便后续计算空闲时间段。
定义一个字符串数组end_time，用于记录每个教室最近的占用结束时间。初始化为"00:00"，表示一开始所有教室都是空闲的。
使用sort()函数按照开始时间对所有请求进行排序。
遍历所有请求，对于第i个请求，遍历所有教室，寻找一个空闲的教室j，使得请求可以在该教室使用。具体地，如果j不等于请求规定的教室编号，则跳过j。如果j等于请求规定的教室编号，计算当前j教室最近的占用结束时间，如果该时间早于i的开始时间，则认为j教室可用，更新占用结束时间。
如果找到了可用的教室，输出该请求使用的教室编号，并将count计数加1。如果没有找到可用的教室，该请求将被忽略。

输出能够成功安排的请求数量。

#include <iostream>
#include <algorithm>
using namespace std;

struct Request {
    string name;
    string start_time;
    string end_time;
    int classroom;
};

// 按开始时间从小到大排序
bool cmp(Request a, Request b) {
    int a_start = stoi(a.start_time.substr(0, 2)) * 60 + stoi(a.start_time.substr(3, 2));
    int b_start = stoi(b.start_time.substr(0, 2)) * 60 + stoi(b.start_time.substr(3, 2));
    return a_start < b_start;
}

int main() {
    Request requests[] = {{"a", "9:00", "10:30", 1}, {"b", "9:00", "12:30", 2}, {"c", "9:00", "10:30", 3}, {"d", "11:00", "12:30", 3}, {"e", "11:00", "14:00", 4}, {"f", "13:00", "14:30", 1}, {"g", "13:00", "14:30", 3} ,{"h", "14:00", "16:30", 2}, {"i", "15:00", "16:30", 1}, {"j", "15:00", "16:30", 4}};
    const int n = sizeof(requests) / sizeof(Request);

    sort(requests, requests + n, cmp); // 按开始时间排序

    string end_time[4] = {"00:00", "00:00", "00:00", "00:00"}; // 初始化为 "00:00"
    int count = 0; // 记录安排的请求数
    for (int i = 0; i < n; i++) {
        int min_end_time = INT_MAX;
        int min_j = -1;
        for (int j = 0; j < 4; j++) {
            if (j != requests[i].classroom) continue; // 如果该请求规定了教室，只在对应的教室中寻找可用时间段
            int cur_end = stoi(end_time[j].substr(0, 2)) * 60 + stoi(end_time[j].substr(3, 2));
            int req_start = stoi(requests[i].start_time.substr(0, 2)) * 60 + stoi(requests[i].start_time.substr(3, 2));
            if (req_start >= cur_end && cur_end < min_end_time) {
                min_end_time = cur_end;
                min_j = j;
            }
        }
        if (min_j != -1) { // 找到一个空闲的教室
            end_time[min_j] = requests[i].end_time;
            count++;
            cout << requests[i].name << " 使用教室 " << min_j << endl;
        }
    }

    cout << "最多可以安排 " << count << " 个请求" << endl;

    return 0;
}

冲突最少

定义结构体Request，表示讲师的教室使用请求。该结构体包含4个成员变量：讲师姓名name、开始时间start_time、结束时间end_time以及第一个安排的教室编号classroom。其中，开始时间和结束时间的格式为HH:MM，且表示24小时制下的时间。
定义常量MAXN为100，表示最多可以处理的请求个数。同时定义全局数组requests存储所有请求，以及数组end_time表示每个教室当前的最近结束时间。
定义函数bool cmp(Request a, Request b)，用来比较两个请求的开始时间，从小到大排序。
定义函数int find_classroom(int start, int end, int except)，用来寻找冲突最少的教室。该函数接收三个参数，分别是当前请求的开始时间start、结束时间end，以及要排除的教室编号except。在这个函数中，我们遍历每一个教室，针对没有被排除的教室进行操作。对于每个教室，如果当前请求的开始时间在该教室的最近结束时间之后，那么该教室可以被分配给当前请求，将其冲突度设为(start - end_time[i])。如果多个教室都可以被分配，我们选择冲突度最小的教室。
在main()函数中，手动预设若干个讲师的请求，并按照开始时间从小到大排序。然后，遍历每个请求，调用find_classroom()函数寻找冲突最少的教室。如果不存在可用的教室，则输出无法安排该请求的信息；否则，将该请求分配给所选教室，并更新该教室的最近结束时间，输出已经安排好的信息。
统计所有成功安排的请求数，输出结果。

总体来说，这个代码基于贪心算法，尽可能地利用了每个教室的时间资源，最大化教室的利用率，同时保证了讲师请求不会发生时间冲突。

#include <iostream>
#include <string>
#include <algorithm>
#include <ctime>
using namespace std;

struct Request {
    string name;
    string start_time;
    string end_time;
    int classroom;
};

const int MAXN = 100;
Request requests[MAXN];
int end_time[4] = {0}; // 记录每个教室最近结束时间

// 按开始时间从小到大排序
bool cmp(Request a, Request b) {
    int a_start = stoi(a.start_time.substr(0, 2)) * 60 + stoi(a.start_time.substr(3, 2));
    int b_start = stoi(b.start_time.substr(0, 2)) * 60 + stoi(b.start_time.substr(3, 2));
    return a_start < b_start;
}

int find_classroom(int start, int end, int except) {
    int min_conflict = MAXN+1; // 初始化为一个较大的数
    int best_classroom = -1;
    for (int i = 0; i < 4; i++) {
        if (i == except) continue;
        if (start >= end_time[i] && (start - end_time[i]) * min_conflict < (end - start)) { // 计算冲突度
            min_conflict = (start - end_time[i]);
            best_classroom = i;
        }
    }
    return best_classroom;
}

int main() {
    Request requests[] = {{"a", "9:00", "10:30", 1}, {"b", "9:00", "12:30", 2}, {"c", "9:00", "10:30", 3}, {"d", "11:00", "12:30", 3}, {"e", "11:00", "14:00", 4}, {"f", "13:00", "14:30", 1}, {"g", "13:00", "14:30", 3} ,{"h", "14:00", "16:30", 2}, {"i", "15:00", "16:30", 1}, {"j", "15:00", "16:30", 4}};
    const int n = sizeof(requests) / sizeof(Request);

    sort(requests, requests+n, cmp); // 按开始时间排序

    int count = 0; // 记录安排的请求数
    for (int i = 0; i < n; i++) {
        int start = stoi(requests[i].start_time.substr(0, 2)) * 60 + stoi(requests[i].start_time.substr(3, 2));
        int end = stoi(requests[i].end_time.substr(0, 2)) * 60 + stoi(requests[i].end_time.substr(3, 2));
        int classroom = find_classroom(start, end, requests[i].classroom);
        if (classroom == -1) { // 没有可用教室
            cout << "无法安排 " << requests[i].name << endl;
        } else {
            requests[i].classroom = classroom;
            end_time[classroom] = end;
            count++;
            cout << requests[i].name << " 使用教室 " << classroom+1 << endl;
        }
    }

    cout << "最多可以安排 " << count << " 个请求" << endl;

    return 0;
}

詹小友

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
教室借用-贪婪算法

因此，在最早开始时间方法的代码实现中，我们可以使用sort函数对请求按照开始时间进行排序，然后从第一个请求开始处理，依次判断每个请求与前面所有已安排的请求的关系，选择开始时间最早且不与前面已安排的请求冲突的请求进行安排。因此，在最早完成时间方法的代码实现中，我们可以使用sort函数对请求按照结束时间进行排序，然后从第一个请求开始处理，依次判断每个请求与前面所有已安排的请求的关系，选择结束时间最早且不与前面已安排的请求冲突的请求进行安排。其中，开始时间和结束时间的格式为HH:MM，且表示24小时制下的时间。
复制链接

扫一扫