动态规划算法-以机房管理系统为例

最新推荐文章于 2024-07-23 17:36:37 发布

码路漫漫任重道远

最新推荐文章于 2024-07-23 17:36:37 发布

阅读量583

点赞数 15

文章标签：算法动态规划

本文链接：https://blog.csdn.net/weixin_64922330/article/details/140253114

版权

1.动态规划算法介绍

1.算法思路

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思路。具体的动态规划算法多种多样，但它们具有相同的填表格式。

2.代码介绍

// 推荐最优上机时间的方法，接收机器ID和上机类型ID作为参数
public static void recommendOptimalSessionTime(int machineID, int typeID) {
    // 获取当前机器的会话列表，即所有已安排的上机时间段
    List<Session> sessions = getSessionsByMachine(machineID); 
    // 计算最优时间槽，基于当前机器的会话列表、上机类型ID
    List<TimeSlot> timeSlots = calculateOptimalTimeSlots(machineID, typeID, sessions); 

    // 如果存在可用的时间槽
    if (!timeSlots.isEmpty()) {
        // 获取效率最高的时间槽
        TimeSlot optimalSlot = timeSlots.get(0); 
        // 打印推荐的最优上机时间详细信息
        System.out.println("推荐的最优上机时间：");
        System.out.println("开始时间：" + optimalSlot.getStartTime());
        System.out.println("结束时间：" + optimalSlot.getEndTime());
        System.out.println("效率：" + optimalSlot.getEfficiency());
    } else {
        // 如果没有可用的时间槽，则输出提示信息
        System.out.println("没有可用的上机时间。");
    }
}

// 交互式方法，提示用户输入机器ID和上机类型ID，并调用算法
private static void recommendOptimalSessionTime() {
    // 用户输入机器ID
    System.out.print("请输入机器ID：");
    int machineID = scanner.nextInt();
    scanner.nextLine();
    // 用户输入上机类型ID
    System.out.print("请输入上机类型ID：");
    int typeID = scanner.nextInt();
    scanner.nextLine();

    // 调用算法执行推荐逻辑，并传入用户输入的机器ID和上机类型ID
    recommendOptimalSessionTime(machineID, typeID);
}

// 核心算法方法，计算最优时间槽
public static List<TimeSlot> calculateOptimalTimeSlots(int machineID, int typeID, List<Session> sessions) {
    List<TimeSlot> timeSlots = new ArrayList<>();
    // 根据上机类型ID获取对应的费率，用于计算效率
    double rate = getRateByTypeID(typeID); 

    // 初始化时间槽，从当前时间开始，每隔30分钟一个槽，持续24小时
    long startTime = System.currentTimeMillis();
    long endTime = startTime + 24 * 60 * 60 * 1000; // 结束时间为当前时间加24小时
    long interval = 30 * 60 * 1000; // 时间槽间隔设置为30分钟

    // 创建时间槽列表
    for (long t = startTime; t < endTime; t += interval) {
        // 每个时间槽从当前时间开始，持续30分钟
        TimeSlot slot = new TimeSlot(new Timestamp(t), new Timestamp(t + interval));
        timeSlots.add(slot);
    }

    // 动态规划计算每个时间槽的效率
  
    for (TimeSlot slot : timeSlots) {
        double efficiency = calculateEfficiency(slot, sessions, rate);
        slot.setEfficiency(efficiency);
    }

    // 按效率从高到低排序时间槽
    timeSlots.sort((a, b) -> Double.compare(b.getEfficiency(), a.getEfficiency()));

    // 返回排序后的最优时间槽列表
    return timeSlots;
}

// 计算单个时间槽的效率的方法
private static double calculateEfficiency(TimeSlot slot, List<Session> sessions, double rate) {
    double efficiency = 0;
    // 遍历所有会话，如果会话与时间槽冲突，则降低效率
    for (Session session : sessions) {
        if (slot.getStartTime().before(session.getEndTime()) && slot.getEndTime().after(session.getStartTime())) {
            efficiency -= rate; // 效率降低，因为会话与时间槽冲突
        }
    }
    // 如果时间槽内没有冲突的会话，则效率增加
    efficiency += rate;
    return efficiency;
}