MM1排队算法在医院预约排队时间预测等的应用

Hw_XINGYU

已于 2025-04-23 23:59:01 修改

阅读量1.7k

点赞数 33

文章标签：算法 java

于 2024-06-15 10:27:16 首次发布

本文链接：https://blog.csdn.net/Hw_XINGYU/article/details/139697672

版权

简介

路线规划功能在体检中心的应用可以极大地提高体检效率和用户体验。以下是该功能的大致思路和实现步骤：

大致思路：

1. 数据收集：

首先，系统需要收集体检中心的体检项目信息，包括每个项目的平均体检时间、所需设备、专业人员等。

2. 用户输入：

用户输入自己的体检套餐或体检项目列表，以及当前的排队人数。

3. 排队时间预测：

系统根据当前排队人数和每个项目的平均体检时间，预测每个项目的排队时间。

4. 算法计算：

使用优化算法（如遗传算法、模拟退火算法、蚁群算法等）来计算最佳的体检顺序。算法的目标是最小化总体检时间，同时考虑到体检项目的依赖关系（如某些项目需要先做其他项目）。

5. 结果输出：

系统将计算出的最佳体检顺序提供给用户，用户可以根据这个顺序进行体检。

实现步骤：

1. 系统设计：

设计一个用户友好的界面，让用户能够轻松输入体检项目和查看推荐的体检顺序。

2. 数据管理：

建立一个数据库来存储体检项目信息、平均体检时间、设备和人员信息等。

3. 排队时间预测模型：

开发一个模型来根据当前排队人数和平均体检时间预测排队时间。

4. 优化算法实现：

实现一个优化算法来计算最佳体检顺序。这个算法需要考虑到体检项目的依赖关系和时间限制。

5. 用户交互：

确保用户能够轻松地输入信息，并且能够清晰地看到推荐的体检顺序。

6. 测试与优化：

在实际体检中心环境中测试该功能，收集反馈并进行优化。

7. 部署上线：

在体检中心部署该功能，并确保系统稳定运行。

通过这样的路线规划功能，体检中心可以提高体检效率，减少用户的等待时间，从而提升整体的体检体验。

M/M/1模型简介

M/M/1模型是一种经典的排队论模型用于描述单服务台（server）的排队系统。在这种模型中，顾客的到达过程遵循泊松分布（Poisson process），服务时间遵循指数分布（exponentially distributed）。M/M/1模型的特性如下：

M/M/1模型的特性：

-到达过程：顾客到达服务系统的过程遵循泊松分布，即顾客到达的时间间隔服从指数分布。

-服务时间：顾客接受服务的时间遵循指数分布，即服务时间是恒定的。

-服务台数量：系统中只有一个服务台。

- 队列长度：队列长度无限制，即可以有无限多的顾客等待服务。

- 到达率：顾客到达服务系统的平均速率，用λ表示。

- 服务率：服务台服务顾客的平均速率，用μ表示。

- 服务强度：服务强度ρ（Traffic intensity）是平均到达率与平均服务率之比，即ρ = λ/μ。

M/M/1模型的关键指标：

- 系统中的平均顾客数（Ls）：系统中顾客的平均数量，包括正在接受服务和正在等待的顾客。

- 队列中的平均顾客数（Lq）：仅包括在队列中等待的顾客的平均数量。

- 顾客的平均逗留时间（Ws）：顾客在系统中从到达至离开的平均时间。

- 顾客的平均等待时间（Wq）：顾客在队列中等待的平均时间。

M/M/1模型的公式：

- 系统中的平均顾客数（Ls）：Ls = λ/μ - λ

- 队列中的平均顾客数（Lq）：Lq = (ρ^2)/(1 - ρ)

- 顾客的平均逗留时间（Ws）：Ws = 1/(μ - λ)

- 顾客的平均等待时间（Wq）：Wq = ρ/(μ - λ)

M/M/1模型的应用：

M/M/1模型广泛应用于各种服务系统，如银行、医院、呼叫中心等，用于预测和优化服务效率。通过计算上述关键指标，管理者可以了解系统的性能，调整服务策略，如增加服务台数量、优化服务流程等，以减少顾客的等待时间，提高服务质量。

M/M/1模型的改进：

- M/M/1/N模型：在M/M/1模型的基础上，引入队列容量限制N，即队列中最多只能有N个顾客等待。

- M/M/1/∞模型：在M/M/1模型的基础上，考虑顾客到达率和服务率的变化，即λ和μ是随时间变化的参数。

实现代码

controller

package Suanfa;
/**************************
 *  M/M/1 核心类 Controller
 **************************/

import java.util.*;
import java.util.Random;

public class Controller {

    public static final int BIRTH = 0;
    public static final int DEATH = 1;

    LinkedList<Event> schedule;     // 事件队列
    double clock;					// 时钟
    double endTime;					// 时钟终止时间
    double nextArrival;				// 服务开始事件
    double nextDeparture;			// 服务结束时间
    double ta;					    // 平均到达时间
    double ts;						// 平均服务时间
    ArrayList<Double> checkpoints;	// 监控测点
    int numChecks;					// 监控测点数

    double Tq,Tw,Ts;
    int w, q;
    int requests, serviced;

    /* 初始化 */
    public Controller(double ta, double ts, double endTime) {
        this.ta = ta;
        this.ts = ts;
        this.endTime = endTime;

        checkpoints = new ArrayList<Double>();
        double n = 0;
        while (n < endTime) {
            numChecks++;
            n += exponential(ta);
            checkpoints.add(n);
        }

        clock = 0;
        schedule = new LinkedList<Event>();
        nextArrival = exponential(1/ta);
        nextDeparture = Double.POSITIVE_INFINITY;

        Tq = 0; Tw = 0; Ts = 0;
        w= 0; q = 0;
        requests = 0; serviced = 0;
    }

    /* 下一个顾客到达 */
    public void birthHandler(double time) {
        if (schedule.isEmpty()) { // 队列为空，执行服务
            scheduleDeath(time);
        }
        else { // 队列不为空，添加此顾客到队列中
            schedule.add(new Event(time,BIRTH));
        }
        nextArrival += exponential(1/ta);
    }


    /* 当前服务结束 */
    public void deathHandler() {
        schedule.remove(); // 事件移除
        if (!schedule.isEmpty()) { // 队列不为空：弹出执行队列中的任务
            Event next = schedule.remove();
            scheduleDeath(next.getTime());
        } else{
            // 队列为空，此时服务器空闲，等待下一任务
            nextDeparture = Double.POSITIVE_INFINITY;
            nextArrival += exponential(1/ta);
        }
    }

    /* 服务执行，计算相关参数 */
    public void scheduleDeath(double arrivalTime) {
        nextDeparture = clock + exponential(1/ts);  // 本次服务结束时间
        schedule.addFirst(new Event(nextDeparture,DEATH));
        serviced++;  // 总服务数
        Tq += (nextDeparture - arrivalTime); // 总逗留时间
        Tw += (clock - arrivalTime);  // 总等待时间
        Ts += (nextDeparture - clock);  // 总服务时间
    }

    /* 监控输出 */
    public void monitorHandler() {
        int cur_q = schedule.size();
        int cur_w = (cur_q > 0) ? (schedule.size() - 1) : 0;
        w += cur_w;
        q += cur_q;
        checkpoints.remove(0);
    }

    /* 指数分布生成函数 */
    public static double exponential(double lambda) {
        Random r = new Random();
        double x = Math.log(1-r.nextDouble())/(-lambda);
        return x;
    }

    /* 主函数 */
    public void run() {
        while (clock < endTime) {
            if (checkpoints.get(0) < nextArrival && checkpoints.get(0) < nextDeparture) {
                // 监控时刻位于服务发生时
                clock = checkpoints.get(0);
                monitorHandler();
            }
            else if (nextArrival <= nextDeparture) { // 下一个顾客的到来
                clock = nextArrival;
                birthHandler(nextArrival);
                requests++;
            }
            else {	// 服务结束
                clock = nextDeparture;
                deathHandler();
            }
        }
        printStats();
    }

    public void printStats() {
        // 输出相关参数
        System.out.println("相关计算参数输出：");
        System.out.println("顾客数目requests: " + requests);
        System.out.println("服务顾客数serviced: " + serviced);
        System.out.println("队列中平均等待客户数q = " + q/numChecks);
        System.out.println("平均等待时间Tw = " + Tw/requests);
        System.out.println("平均逗留时间Tq = " + Tq/serviced);
        System.out.println("平均服务时间Ts = " + Ts/serviced);
        System.out.println("服务器利用率 = " + Ts/endTime);
    }
}

event类

package Suanfa;
/**************************
 *  M/M/1 事件类
 **************************/



public class Event {
    private double time;
    private int type;

    public Event(double t, int e) {
        this.time = t;
        this.type = e;
    }

    public double getTime() {
        return time;
    }

    public int getType() {
        return type;
    }
}

main

package Suanfa;

/********************
 *  M/M/1 队列模型
 *******************/
public class Main {

    public static void main(String[] args) {

        double ta = 0.015;  // 平均到达时间
        double ts = 0.015;  // 平均服务时间
        double length = 100;  // 监控时钟终点
        Controller c1 = new Controller(ta,ts,length);
        System.out.println("仿真 1: 平均到达时间ta = " + ta + ", 平均服务时间ts = " + ts + ", 监控时钟终点 length = " + length);
        c1.run();
        System.out.println("仿真结束");
    }

}