智慧农业大棚
数据处理与优化
任务单

import java.util.*;

public class TemperatureSearch {

    /**
     * 查找给定时间点的最近温度值
     * @param records    温度记录列表，按时间升序排列
     * @param targetTime 目标查询时间（格式："HH:mm"）
     * @return 该时刻或该时刻之前最近的温度值，若无则返回 null
     */
    public static Double findLatestTemperature(
            List<TemperatureRecord> records, String targetTime) {

    }

    public static void main(String[] args) {
        List<TemperatureRecord> records = Arrays.asList(
            new TemperatureRecord("08:00", 15.0),
            new TemperatureRecord("09:00", 17.0),
            new TemperatureRecord("10:00", 20.0),
            new TemperatureRecord("11:00", 23.0),
            new TemperatureRecord("12:00", 26.0)
        );
        runTests(records);
    }

    // …… runTests / 辅助方法见完整代码 ……
}

class TemperatureRecord {
    String time;         // 格式 "HH:mm"
    double temperature;  // 单位 °C
    public TemperatureRecord(String time, double temperature) {
        this.time = time;
        this.temperature = temperature;
    }
}

public class ConfigVersionStack {

    private DeviceConfig[] stack;
    private int top = -1;
    private final int MAX_VERSIONS = 50;

    /** 提交新配置（压栈） */
    public void commit(DeviceConfig config) { ... }

    /** 回滚至上一版本（弹栈） */
    public DeviceConfig rollback() { ... }

    /** 查看当前生效配置（不弹出） */
    public DeviceConfig currentConfig() { ... }

    /** 打印所有历史版本 */
    public void printHistory() { ... }
}

public class CommandQueue {

    private Command[] buffer;
    private int head = 0, tail = 0, size = 0;

    /** 入队：推送新指令 */
    public synchronized void enqueue(Command cmd) throws InterruptedException { ... }

    /** 出队：取出下一条待执行指令 */
    public synchronized Command dequeue() throws InterruptedException { ... }

    /** 查看队头指令（不出队） */
    public Command peek() { ... }

    /** 当前队列中待处理指令数 */
    public int pendingCount() { ... }
}

public class DeviceRegistry {

    private LinkedList<Device>[] buckets;
    private int capacity, size;
    private static final float LOAD_FACTOR = 0.75f;

    /** 注册新设备 */
    public void register(Device device) { ... }

    /** 根据ID查询设备信息 */
    public Device query(String deviceId) { ... }

    /** 更新设备在线状态 */
    public void updateStatus(String deviceId, boolean online) { ... }

    /** 注销设备 */
    public void deregister(String deviceId) { ... }

    /** 负载超阈值时触发扩容 */
    private void rehash() { ... }
}

public class PermissionTree {

    private PermissionNode root;

    /** 在指定父节点下添加新角色节点 */
    public void addRole(String parentRole, PermissionNode child) { ... }

    /** 校验指定角色是否有操作某设备的权限 */
    public boolean hasPermission(String role, String deviceId, String action) { ... }

    /** DFS 遍历打印完整权限树 */
    public void printTree(PermissionNode node, int depth) { ... }

    /** 对某子树内所有节点批量降权 */
    public void revokeSubTree(String rootRole, String action) { ... }
}

public class DeviceTrie {

    private final TrieNode root = new TrieNode();

    /** 插入设备名称 */
    public void insert(String deviceName) { ... }

    /** 精确查询设备名称是否存在 */
    public boolean search(String name) { ... }

    /** 前缀搜索：返回所有匹配的设备名称 */
    public List<String> autocomplete(String prefix) { ... }

    /** 删除设备名称（后序递归清理空节点） */
    public boolean delete(String deviceName) { ... }

    /** 统计以 prefix 开头的设备数量 */
    public int countWithPrefix(String prefix) { ... }
}

public class IrrigationScheduler {

    private MinHeap<IrrigationTask> taskHeap;

    /** 添加灌溉任务（自动按时间排序） */
    public void schedule(IrrigationTask task) { ... }

    /** 取出最近到期任务（不等待） */
    public IrrigationTask pollNext() { ... }

    /** 取消指定ID的任务 */
    public boolean cancel(String taskId) { ... }

    /** 调度主循环（阻塞式，直到有任务到期） */
    public void runScheduleLoop() {
        while (true) {
            IrrigationTask top = taskHeap.peek();
            if (top != null && top.executeAt <= System.currentTimeMillis()) {
                execute(taskHeap.poll());
            }
            // 短暂休眠，避免忙等
            Thread.sleep(100);
        }
    }
}

public class PipelineOptimizer {

    private List<Node> nodes;
    private List<Edge> edges;

    /** Kruskal 算法求 MST */
    public List<Edge> kruskal() {
        // 1. 按边权重升序排序
        // 2. 初始化并查集
        // 3. 遍历每条边，若不成环则加入 MST
        ...
    }

    /** Prim 算法求 MST */
    public List<Edge> prim(int startNode) {
        // 1. 初始化访问集合和最小堆
        // 2. 每次取堆中最短边，若目标节点未访问则加入 MST
        ...
    }

    /** 并查集：查找根节点（路径压缩） */
    private int find(int[] parent, int x) { ... }

    /** 并查集：合并两个集合（按秩合并） */
    private void union(int[] parent, int[] rank, int a, int b) { ... }

    /** 计算选定方案的总成本 */
    public double totalCost(List<Edge> mst) { ... }
}