最大流解决医生排班问题

已于 2023-07-15 10:28:06 修改
阅读量617 收藏 4
点赞数 1
分类专栏： 算法设计与分析 文章标签： 网络
于 2023-07-08 14:47:44 首次发布
叶茂林
本文链接：https://blog.csdn.net/weixin_62264287/article/details/131611869
版权
文章详细介绍了如何使用最大流算法，包括Ford-Fulkerson方法、Edmonds-Karp算法和Dinic算法，解决医生在公共假期值班的排班问题。通过建立流网络模型，展示了这些算法如何寻找满足每个假日都有医生值班且医生值班不超过特定天数的解决方案。实验结果显示，Dinic算法在效率上优于其他两种算法。
摘要由CSDN通过智能技术生成

目录

问题描述

场景建模

Ford-Fulkerson方法

Edmonds-karp算法

Dinic算法

问题描述

一个医院有n名医生，现有k个公共假期需要安排医生值班。每一个公共假期由若干天（假日）组成，第j个假期包含的假日用 Dj表示，那么需要排班的总假日集合为  ，如图1所示。例如，“五一”假期由5月1日至5月7日一共7个假日组成。“元旦”假期由1月1日至1月3日一共3个假日组成。

图1 问题示例

每名医生i可以值班的假日集合是 Si，Si⊆D。例如，李医生可以值班的假日集合包括“五一”假期中的5月3日、5月4日和“元旦”假期中的1月2日。

设计一个排班的方案使得每个假日都有一个医生值班并且满足下面两个条件：

  • 每个医生最多只能值班c个假日；
  • 每个医生在一个假期中只能值班1个假日。例如，安排李医生在“五一”假期中的5月4日值班。

根据上述场景完成下面任务：

  • 实例化上述场景中的参数，生成数据。
  • 设计一个多项式时间的算法求解上述问题。
  • 基于生成的数据，设计一个流网络。
  • 解释说明该流网络中最大流与值班问题的解的关系。
  • 基于生成的数据，计算出排班的方案。

场景建模

我们首先具体化医生排班问题的参数，例如：假设一个医院有2名医生，现有国庆节和劳动节两个假期需要安排医生值班，假设两个假期假日都为2天。

A医生可以值班的假日为国庆假的第一天和第二天以及劳动节的第一天。B医生可以值班的假日为国庆假的第一天和劳动节的第二天。

设计一个排班的方案使得每个假日都有一个医生值班并且满足下面两个条件：

1. 每个医生最多只能值班2个假日；

2. 每个医生在一个假期中只能值班1个假日。

建立流网络

我们首先根据问题生成一个流网络，如图2所示，先创建一个超级源点S，让超级源点S到每个医生的流量都是2，即让每个医生至多值班2天；然后创建流网络的中间节点，并限制路径上的最大流量为1，即限制一个医生在一个假期中最多只值班一天；最后创建一个超级汇点T，让每个假日到超级汇点的流量都是1，即让每个假日都有一个医生值班。

图2 网络流的建立

然后给每个节点编号，上面的流网络等价于下面图3的流网络模型。若要得到满足问题的解，那么需要满足每个假日到超级汇点的流量都为1，即问题等价成要寻找该流网络中的一个最大流。

图3 流网络模型

Ford-Fulkerson方法

Ford-Fulkerson方法是解决最大流问题的一种经典方法，包含几种运行时间的实现，其依赖于三种重要思想，即残存网络、增广路径和切割。

  • 残存网络：在原有网络上构造出来的一种新的网络结构，它表示了在当前剩余容量下，从源点到汇点的可行流量，残余网络中的源点和汇点与原有网络相同，是辅助建立新图的一种方法，在每次增广过程中，都要在残留网络中找到一条增广路径，并将该路径上的流量加入到当前的流中。
  • 增广路径：一条从源点到汇点的路径，满足该路径上的任意一条边的剩余容量都大于0。
  • 最小割：指将原有网络G(V, E)划分成两个不相交的集合(A, B)，使得A中的所有节点都无法到达B中的所有节点，在满足这一条件的情况下，将划分这两个集合的所有边的容量之和称为最小割。

Ford-Fulkerson方法通过不断地在残留网络中搜索出增广路径，并根据增广路径更新剩余容量的方式来寻找最大流。每次增广的过程中，都会选择一条从源点到汇点的路径，然后将这条路径上的流量增加到当前的最大流中。随着可行流的不断增加，残留网络中的剩余容量也不断减少，直到找不到增广路径为止。

具体来说，首先根据流网络的最大流容量构建出残存网络，如图4所示。

图4 构建残存网络

接着搜索残存网络中的每一条增广路径，如图5所示，然后使用残存容量来对增广路径上的流进行加增，如果残存边是原来网络中的一条边，则加增流量，否则缩减流量。

图5 搜索增广路径更新网络流量

根据我们上面证明过的最大流最小割定理，f是G中的一个最大流当且仅当其对应的残存网络中不包含任何的增广路径，如图6所示，当残存网络中没有增广路径时，就已经找到了一个最大流。

图6 最大流

根据我们找到的最大流可知，与原流网络相比，结点3和结点7之间没有流通过，即A医生不值国庆节第一天的班，如图7所示，最后得出的方案是：A医生值国庆节的第二天班和劳动节的第一天班，B医生值国庆节的第一天班和劳动节的第二天班。

图7 医生排班方案

程序实现

定义一个Map 类表示一个有向图，使用一个二维数组记录每条边的容量，利用 DFS 不断寻找增广路径，从源点开始递归遍历未被访问过的相邻节点，如果当前节点是汇点则返回流量，否则继续递归寻找增广路径，返回从当前节点出发能够到达汇点的最大流量，同时更新相应的网络流。

C++代码 

//
// Created by YEZI on 2023/6/20.
//

#ifndef MAX_FLOW_FORD_FULKERSON_H
#define MAX_FLOW_FORD_FULKERSON_H

#include<iostream>
#include<fstream>

using namespace std;
namespace Ford_Fulkerson {
    class Map {
        int **map;
        bool *visited;
        int edgeNumber;
        int vertexNumber;
        int max_flow = 0;
        int sink;

        int DFS(const int current, int min_flow) {
            if (current == sink) {
                return min_flow;
            }
            visited[current] = true;
            for (int i = 0; i < vertexNumber; i++) {
                if (map[current][i] && !visited[i]) {
                    int next_flow = DFS(i, min(map[current][i], min_flow));
                    if (next_flow) {
                        map[current][i] -= next_flow;
                        map[i][current] += next_flow;
                        return next_flow;
                    }
                }
            }
            return 0;
        }

    public:
        void find_max_flow() {
            while (true) {
                fill(visited, visited + vertexNumber, false);
                int flow = DFS(0, 1314520);
                if (flow == 0)
                    break;
                max_flow += flow;
            }
        }

        void show() {
            cout << "Max flow is " << max_flow << endl;
            for (int i = 0; i < vertexNumber; i++) {
                for (int j = 0; j < vertexNumber; j++) {
                    if (map[i][j] && i < j)
                        cout << '<' << i << ',' << j << "> is abandoned." << endl;
                }
            }
        }
        Map(){
            fstream file(R"(C:\Users\Yezi\Desktop\C++\max_flow\data.txt)");
            if (!file.is_open()) {
                cout << "File Open Error!" << endl;
                return;
            }
            file >> vertexNumber >> edgeNumber;
            map = new int *[vertexNumber];
            visited = new bool[vertexNumber];
            for (int i = 0; i < vertexNumber; i++) {
                map[i] = new int[vertexNumber];
                fill(map[i], map[i] + vertexNumber, 0);
            }
            sink = vertexNumber - 1;
            int head, tail, capacity;
            while (!file.eof()) {
                file >> head >> tail >> capacity;
                map[head][tail] = capacity;
            }
        }
        Map(const int doctor_num,const int holiday_num,const int day_num,const int capacity) {
            vertexNumber=1+doctor_num+doctor_num*holiday_num+holiday_num*day_num+1;
            map = new int *[vertexNumber];
            visited = new bool[vertexNumber];
            for (int i = 0; i < vertexNumber; i++) {
                map[i] = new int[vertexNumber];
                fill(map[i], map[i] + vertexNumber, 0);
            }
            sink = vertexNumber - 1;
            for(int doctor=1;doctor<=doctor_num;doctor++){
                map[0][doctor]=capacity;
            }
            for(int doctor=1;doctor<=doctor_num;doctor++){
                for(int holiday=0;holiday<holiday_num;holiday++){
                    int tail=1+doctor_num+doctor_num*holiday+doctor-1;
                    map[doctor][tail]=1;
                    int head=tail;
                    bool select[day_num];
                    fill(select,select+day_num,false);
                    for(int day=0;day<day_num/2+1;day++){
                        int index=rand()%day_num;
                        if(select[index]){
                            day--;
                            continue;
                        }
                        select[index]= true;
                        tail=1+doctor_num+doctor_num*holiday_num+day_num*holiday+index;
                        map[head][tail]=1;
                    }
                }
            }
            for(int day=0;day<holiday_num*day_num;day++){
                map[1+doctor_num+doctor_num*holiday_num+day][sink]=1;
            }
        }
    };
}
#endif //MAX_FLOW_FORD_FULKERSON_H

用DFS实现的Ford-Fulkerson方法的运行结果如图8所示，找到最大流为4，结点3和结点7之间没有流通过，可以确认正确性。

图8 Ford-Fulkerson DFS实现运行结果

数据测试

固定假期数为20个，每个假期的天数为7天，一个医生最多可以值班10个假日，然后生成不同规模的医生数量进行测试，结果如图9所示。

图9 Ford-Fulkerson(DFS)测试

具体数据如表1所示。

表1 Ford-Fulkerson(DFS)测试

由结果可以看出，随着医生数量的增长，程序运行的时间呈线性增长。

Edmonds-karp算法

Edmonds-karp算法是Ford-Fulkerson方法的一种实现，其主要思想是在残量网络上使用 BFS 查找增广路径，如图10所示，与我们上一个使用DFS实现不同，Edmonds-Karp 算法首先在残量网络上进行 BFS查找从源点到汇点的一条增广路径，然后根据增广路径更新流网络直到残存网络中没有增广路径为止。

图10 Edmonds-karp算法

C++代码 

//
// Created by YEZI on 2023/6/20.
//

#ifndef MAX_FLOW_EDMONDS_KARP_H
#define MAX_FLOW_EDMONDS_KARP_H

#include<iostream>
#include<fstream>
#include<queue>

using namespace std;
namespace Edmonds_Karp {
    class Map {
        int **map;
        int *pre;
        int *flow;
        int vertexNumber;
        int edgeNumber;
        int max_flow = 0;
        int source;
        int sink;

        bool BFS() {
            queue<int> q;
            vector<bool> visited(vertexNumber, false);
            flow[source] = INT_MAX;
            visited[source] = true;
            q.push(source);

            while (!q.empty()) {
                int current = q.front();
                q.pop();
                for (int i = 0; i < vertexNumber; i++) {
                    if (!visited[i] && map[current][i]) {
                        flow[i] = min(flow[current], map[current][i]);
                        pre[i] = current;
                        visited[i] = true;
                        if (i == sink)
                            return true;
                        q.push(i);
                    }
                }
            }
            return false;
        }

    public:
        void find_max_flow() {
            while (BFS()) {
                int f = flow[sink];
                max_flow += f;
                for (int i = sink; i != source; i = pre[i]) {
                    map[pre[i]][i] -= f;
                    map[i][pre[i]] += f;
                }
            }
        }

        void show() {
            cout << "Max flow is " << max_flow << endl;
            for (int i = 0; i < vertexNumber; i++) {
                for (int j = 0; j < vertexNumber; j++) {
                    if (map[i][j] && i < j)
                        cout << '<' << i << ',' << j << "> is abandoned." << endl;
                }
            }
        }

        Map() {
            fstream file(R"(C:\Users\Yezi\Desktop\C++\max_flow\data.txt)");
            if (!file.is_open()) {
                cout << "File Open Error!" << endl;
                return;
            }
            file >> vertexNumber >> edgeNumber;
            map = new int *[vertexNumber];
            pre = new int[vertexNumber];
            flow = new int[vertexNumber];
            for (int i = 0; i < vertexNumber; i++) {
                map[i] = new int[vertexNumber];
                fill(map[i], map[i] + vertexNumber, 0);
            }
            int head, tail, capacity;
            while (!file.eof()) {
                file >> head >> tail >> capacity;
                map[head][tail] = capacity;
            }
            source = 0;
            sink = vertexNumber - 1;
        }
        Map(const int doctor_num,const int holiday_num,const int day_num,const int capacity) {
            vertexNumber=1+doctor_num+doctor_num*holiday_num+holiday_num*day_num+1;
            map = new int *[vertexNumber];
            pre = new int[vertexNumber];
            flow = new int[vertexNumber];
            for (int i = 0; i < vertexNumber; i++) {
                map[i] = new int[vertexNumber];
                fill(map[i], map[i] + vertexNumber, 0);
            }
            sink = vertexNumber - 1;
            source = 0;
            for(int doctor=1;doctor<=doctor_num;doctor++){
                map[0][doctor]=capacity;
            }
            for(int doctor=1;doctor<=doctor_num;doctor++){
                for(int holiday=0;holiday<holiday_num;holiday++){
                    int tail=1+doctor_num+doctor_num*holiday+doctor-1;
                    map[doctor][tail]=1;
                    int head=tail;
                    bool select[day_num];
                    fill(select,select+day_num,false);
                    for(int day=0;day<day_num/2+1;day++){
                        int index=rand()%day_num;
                        if(select[index]){
                            day--;
                            continue;
                        }
                        select[index]= true;
                        tail=1+doctor_num+doctor_num*holiday_num+day_num*holiday+index;
                        map[head][tail]=1;
                    }
                }
            }
            for(int day=0;day<holiday_num*day_num;day++){
                map[1+doctor_num+doctor_num*holiday_num+day][sink]=1;
            }
        }
    };
}
#endif //MAX_FLOW_EDMONDS_KARP_H

数据测试

首先使用我们图2的流网络进行测试验证算法的正确性，结果如图11所示，找到最大流为4，结点3和结点7之间没有流通过，说明算法正确，Edmonds-karp算法可以正确的解决医生排班问题。

图10 Edmonds-karp运行结果

固定假期数为20个，每个假期的天数为7天，一个医生最多可以值班10个假日，然后生成不同规模的医生数量进行测试，并与之前DFS实现的Ford-Fulkerson（简记为FF-DFS）方法做对比，结果如图11所示，Edmonds-karp简记为EK-BFS。

图11 Edmonds-karp测试

具体数据如表2所示。

表2 Edmonds-karp测试

由结果可知，与线性增长的DFS实现的Ford-Fulkerson方法不同，BFS实现的Edmonds-karp算法是随着医生数量的增长呈2次方式增长，BFS之所以慢于DFS是因为在医生排班问题中，流网络的层次固定为五层，DFS的效率不会低，而Edmonds-karp使用的BFS会随着医生数量的增长而搜索的宽度增加，因此更慢。

Dinic算法

我们可以观察到，如图12所示，医生排班问题具有非常强的层次感，Dinic算法利用分层图的思想，在每一阶段搜索增广路径时只沿着分层图上深度逐渐加深的路径进行搜索。

图12 医生排班的强层次感

具体来说，Dinic算法首先使用BFS将所有节点分为不同的层级，然后使用DFS在深度逐渐加深的路径上进行搜索，如图13所示，每一条边只能跨越相邻层级之间的节点。每一次增广的路径新加的边都是从深层到浅层的，不会再次经过之前已经走过的边，从而减少重复计算。

图13 Dinic算法

C++代码

//
// Created by YEZI on 2023/6/20.
//

#ifndef MAX_FLOW_DINIC_H
#define MAX_FLOW_DINIC_H

#include<iostream>
#include<fstream>
#include<queue>

using namespace std;
namespace Dinic {
    class Map {
        int **map;
        int *pre;
        int *cur;
        int *flow;
        int *dis;
        int vertexNumber;
        int edgeNumber;
        int max_flow = 0;
        int source;
        int sink;

        bool BFS() {
            queue<int> q;
            fill(dis, dis + vertexNumber, -1);
            flow[source] = INT_MAX;
            dis[source] = 0;
            q.push(source);

            while (!q.empty()) {
                int current = q.front();
                q.pop();
                for (int i = 0; i < vertexNumber; i++) {
                    if (dis[i] == -1 && map[current][i]) {
                        flow[i] = min(flow[current], map[current][i]);
                        pre[i] = current;
                        dis[i] = dis[current] + 1;
                        if (i == sink)
                            return true;
                        q.push(i);
                    }
                }
            }
            return false;
        }

        int DFS(int u, int limit) {
            if (u == sink || !limit)
                return limit;
            int totalFlow = 0;
            for (int &i = cur[u]; i < vertexNumber; i++) {
                if (dis[i] == dis[u] + 1 && map[u][i]) {
                    int d = DFS(i, min(limit, map[u][i]));
                    if (!d) {
                        dis[i] = -1;
                    } else {
                        limit -= d;
                        totalFlow += d;
                        map[u][i] -= d;
                        map[i][u] += d;
                        if (!limit)
                            break;
                    }
                }
            }
            return totalFlow;
        }

    public:
        void find_max_flow() {
            while (BFS()) {
                memcpy(cur, map[source], sizeof(int) * vertexNumber);
                max_flow += DFS(source, INT_MAX);
            }
        }

        void show() {
            cout << "Max flow is " << max_flow << endl;
            for (int i = 0; i < vertexNumber; i++) {
                for (int j = 0; j < vertexNumber; j++) {
                    if (map[i][j] && i < j)
                        cout << '<' << i << ',' << j << "> is abandoned." << endl;
                }
            }
        }

        Map() {
            fstream file(R"(C:\Users\Yezi\Desktop\C++\max_flow\data.txt)");
            if (!file.is_open()) {
                cout << "File Open Error!" << endl;
                return;
            }
            file >> vertexNumber >> edgeNumber;
            map = new int *[vertexNumber];
            pre = new int[vertexNumber];
            cur = new int[vertexNumber];
            flow = new int[vertexNumber];
            dis = new int[vertexNumber];
            for (int i = 0; i < vertexNumber; i++) {
                map[i] = new int[vertexNumber];
                fill(map[i], map[i] + vertexNumber, 0);
            }
            int head, tail, capacity;
            while (!file.eof()) {
                file >> head >> tail >> capacity;
                map[head][tail] = capacity;
            }
            source = 0;
            sink = vertexNumber - 1;
        }

        Map(const int doctor_num,const int holiday_num,const int day_num,const int capacity) {
            vertexNumber=1+doctor_num+doctor_num*holiday_num+holiday_num*day_num+1;
            map = new int *[vertexNumber];
            pre = new int[vertexNumber];
            cur = new int[vertexNumber];
            flow = new int[vertexNumber];
            dis = new int[vertexNumber];
            for (int i = 0; i < vertexNumber; i++) {
                map[i] = new int[vertexNumber];
                fill(map[i], map[i] + vertexNumber, 0);
            }
            sink = vertexNumber - 1;
            source = 0;
            for(int doctor=1;doctor<=doctor_num;doctor++){
                map[0][doctor]=capacity;
            }
            for(int doctor=1;doctor<=doctor_num;doctor++){
                for(int holiday=0;holiday<holiday_num;holiday++){
                    int tail=1+doctor_num+doctor_num*holiday+doctor-1;
                    map[doctor][tail]=1;
                    int head=tail;
                    bool select[day_num];
                    fill(select,select+day_num,false);
                    for(int day=0;day<day_num/2+1;day++){
                        int index=rand()%day_num;
                        if(select[index]){
                            day--;
                            continue;
                        }
                        select[index]= true;
                        tail=1+doctor_num+doctor_num*holiday_num+day_num*holiday+index;
                        map[head][tail]=1;
                    }
                }
            }
            for(int day=0;day<holiday_num*day_num;day++){
                map[1+doctor_num+doctor_num*holiday_num+day][sink]=1;
            }
        }
    };
}

#endif //MAX_FLOW_DINIC_H

数据测试

首先使用我们图2的流网络进行测试验证算法的正确性，结果如图14所示，找到最大流为4，结点3和结点7之间没有流通过，说明算法正确，Dinic算法可以正确的解决医生排班问题。

图14 Dinic算法运行结果

固定假期数为20个，每个假期的天数为7天，一个医生最多可以值班10个假日，然后生成不同规模的医生数量进行测试，并与之前DFS实现的Ford-Fulkerson方法做对比，结果如图15所示。

图15 Dinic算法测试

具体数据如表3所示。

表3 Dinic算法测试

由结果可知，Dinic算法的执行效率要快于Edmonds-karp算法，理论上要快于DFS实现的Ford-Fulkerson算法，但是由于医生排班问题的流网络只有五层，DFS的效率仍然是非常高的。

MaolinYe（叶茂林）
关注
专栏目录
排班问题——Nurse Rostering Problem（NRP）实战
pascal_lin
03-25 6770
文章目录背景问题调研工具查找——找巨人的肩膀ActionCode exampleor-tools的基本用法参数调整画甘特图总结 背景 上次周末碰到女朋友在排班表，花了快一个小时，就想着看用代码帮她节省点时间。 问题调研 上网查了一下，看了几篇论文了解了背景。 http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.1030.5363&rep=rep1&type=pdf https://arxiv.org/pdf/1804.05002
Edmonds-Karp算法（EK算法）简单讲解及实现（邻接表）
AKGWSB 's blog
06-06 7316
目录最大流问题介绍图定义源点与汇点最大流问题描述Ford-Fulkerson方法回退边与增广图伪代码图解Edmonds-Karp算法复杂度代码实现细节代码 最大流问题介绍 图定义 给定一张有向图，a->b 边的权值表示当前情况下，从a到b能够发送的流量上限是多少，比如 a->b = 10 表示当前能够从a发10流量给b，当然我们也可以选择不发那么多。 例子： 假设a->b 之间未有任何流量的发送，此时我们发8流量，那么 a->b = 10 变为 a->b = 2 ，a->
【船舶调度】基于模拟退化算法的船舶进港排班优化问题附matlab代码
最新发布
m0_60703264的博客
03-29 1353
船舶进港排班优化问题是船舶调度中的一个重要问题，其目标是合理安排船舶进港时间和泊位分配，以提高港口吞吐量和降低船舶等待时间。本文提出了一种基于模拟退化算法的船舶进港排班优化模型，该模型考虑了船舶类型、泊位类型、潮汐影响等因素，并通过模拟退化算法求解该模型，得到了最优的船舶进港排班方案。
【算法设计与分析】6 最大流应用问题
深大cs课程实验及学习笔记，ccfcsp部分真题，华为题库
06-23 2600
最大流算法思想。 最大流算法求解应用问题。 一个医院有n名医生，现有 k个公共假期需要安排医生值班。每一个公共假期由若干天（假日）组成，第 j 个假期包含的假日用 Dj 表示，那么需要排班的总假日集合为 D=∪j=1kDj 。例如，“五一”假期由5月1日至5月7日一共7个假日组成。“元旦”假期由1月1日至1月3日一共3个假日组成。 每名医生 i 可以值班的假日集合是 Si ，Si⊆D 。例如，李医生可以值班的假日集合包括“五一”假期中的5月3日、5月4日和“元旦”假期中的1月2日。 ......
最大流 --- Edmond Karp算法
梅子酒的博客
07-30 1298
本文转载于最大流 — Edmond Karp算法因原文部分图片及代码显示问题，阅读不方便，故转载。 Edmond Karp算法的大概思想： 反复寻找源点s到汇点t之间的增广路径，若有，找出增广路径上每一段[容量-流量]的最小值delta，若无，则结束。 在寻找增广路径时，可以用BFS来找，并且更新残留网络的值(涉及到反向边)。 而找到delta后，则使最大流值加上delta，更新为当前的最大流值。 (粗体表明需要掌握的概念) 关于反向边： 以下摘至HDOJ的课件和网上的： 首先来看一下基本的网络流最大流模型
OM | 运筹学在医疗运营管理中的应用
运筹OR帷幄
02-08 654
作者：沈一华（清华大学） 茹伟明（香港理工大学） 本文基于Abdur Rais和Ana Viana 在International Transactions in Operational Research期刊中发表的论文“Operations Research in Healthcare: a survey”介绍了医疗运营管理中的不同应用场景，并探讨了常见的运筹学解决方案。 随着众多发达国家出生率的下降和全球平均寿命的增加，医疗中的优化问题正得到运筹学界越来越多的关注。多年来，人们的关注重点从资源分配和.
医疗行业模型决策法分析.pptx
10-02
分派问题，如护士排班或医生科室分配，旨在将有限的资源有效地分配到多个任务或位置。通过解决这个问题，可以平衡工作量，提高医疗服务质量和患者满意度。 最短路问题和最大流问题在医疗信息系统的设计中至关重要，...
关于眼科病房安排模型论文
09-13
4. **医生和护士排班**：结合医护人员的专业技能、工作负荷和休息时间，制定合理的排班计划，保证医疗服务的质量和效率。 5. **手术室调度**：眼科手术通常需要预约，手术室的时间利用率是关键。模型需要考虑手术时...
尚医通项目--20个技术栈个人总结
COCoDΣ的博客
03-16 3209
1. Mybatis-Plus 2. Swagger2 3. 自定义全局异常处理 4. LogBack 5. EasyExcel 6. Spring Cache 7. Redis 8. Nginx 9. MongoDB 10. 图片Bash64编码工具类 11. Nacos 12. Feign 13. Gateway 14. JWT 15. 阿里云短信服务 16. 用户认证和网关整合 17. OAuth2 微信登录 18. 阿里云OSS对象存储服务 19. RabbitMQ 20.Docker
2020爱分析·智能通讯云厂商全景报告
热门推荐
科讯财闻
11-30 3万+
报告摘要 企业面临业务增长的压力，通讯能力建设成为对内提升运营效率，对外提升产品竞争力和客户体验的重要手段，通讯云的场景应用正在加速渗透。 基于对国内各行业甲方企业的调研，爱分析认为智能通讯云应用呈现以下趋势： • 在提高内部运营效率方面，企业需要通过强化统一通讯能力，及提高办公智能化的方式实现； • 对于企业的客服部门或呼叫中心而言，跑马圈地的时代已经过去，随着企业营销与服务渠道多元化，重心在促进营销转化与提升客户体验； • 针对各行业的不同业务场景，通讯能力不仅是音视频交互工具的基础，还需..
医生一周排班显示 使用SQL语句使数据从坚向排列转化成横向排列排班表
书写人生
05-22 2306
[导读]Extract 属于 SQL 的 DML（即数据库管理语言）函数，同样，InterBase 也支持 Extract，它主要用于从一个日期或时间型的字段内抽取年、月、日、时、分、秒数据，因此，它支持其关健字 YEAR、MONTH、DAY、HOUR、MINUTE、SECOND、WEEKDAY、YEARDAY。 知识重点： 1.extract(day from schedule01::tim...
【算法】基于优先级的排班算法实现
LZGS_4的专栏
03-30 1万+
基于优先级的排班算法实现
算法导论—最大流(Edmonds-Karp算法)
掉下个小石头
07-20 1681
华电北风吹 天津大学认知计算与应用重点实验室 2016-07-20有向图的最大流算法代码模板。利用广度优先搜索寻找残量网络增广路。参考代码：#include <iostream> #include <vector> #include <queue> using namespace std;#define maxn 10 #define INT_MIN 0x80000000struct Edg
医生排班管理系统springboot实战项目
04-04
本项目基于Spring Boot框架，实现了医生排班管理系统，包括医生信息管理、排班设置、排班查询等功能。具体实现如下： 1. 技术选型 - Spring Boot：基于Spring框架的快速开发框架。 - MyBatis：ORM框架，用于操作数据库。 - MySQL：关系型数据库，存储数据。 2. 数据库设计 本项目使用MySQL数据库，设计了三张表：Doctor、Schedule和ScheduleDetail。 Doctor表存储医生信息，包括姓名、性别、科室、职称等字段。 Schedule表存储排班信息，包括排班日期、星期几、班次等字段。 ScheduleDetail表存储具体排班信息，包括排班ID、医生ID、排班日期、班次等字段。 3. 代码实现 （1）DoctorController类 该类实现了医生信息的增删改查功能，包括通过姓名、性别、科室、职称等条件查询医生信息。 （2）ScheduleController类 该类实现了排班信息的增删改查功能，包括通过日期、星期几、班次等条件查询排班信息。 （3）ScheduleDetailController类 该类实现了排班详情的增删改查功能，包括通过排班ID、医生ID、排班日期、班次等条件查询排班详情信息。 （4）DoctorMapper接口 该接口定义了医生信息的数据库操作，包括增删改查等方法。 （5）ScheduleMapper接口 该接口定义了排班信息的数据库操作，包括增删改查等方法。 （6）ScheduleDetailMapper接口 该接口定义了排班详情的数据库操作，包括增删改查等方法。 4. 总结 本项目实现了医生排班管理系统的基本功能，包括医生信息管理、排班设置、排班查询等。通过本项目的实战，可以加深对Spring Boot框架的理解和使用，同时也能够了解到ORM框架MyBatis的使用方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MaolinYe（叶茂林）

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值