解题思路

这是一道时间区间查询问题，主要思路如下：

  1. 问题分析：

    • 输入包含多条订单记录
    • 每条记录包含订单号、入店时间、离店时间
    • 需要查找指定时间点在入店和离店时间之间的订单
    • 结果需要按订单号升序排序

  2. 解决方案：

    • 使用结构体存储订单信息
    • 遍历所有订单判断时间是否符合要求
    • 将符合条件的订单号存入数组
    • 对结果进行排序后输出

  3. 实现细节：

    • 使用结构体封装订单信息
    • 使用数组存储符合条件的订单号
    • 使用排序函数对结果排序

代码

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

const int MAXN = 50005;

struct Order {
    int id;
    int start;
    int leave;
};

int main() {
    int n;
    cin >> n;
    int queryTime;
    cin >> queryTime;
    
    Order orders[MAXN];
    int result[MAXN];
    int count = 0;
    
    // 读取订单信息
    for(int i = 0; i < n; i++) {
        cin >> orders[i].id >> orders[i].start >> orders[i].leave;
        // 判断是否在时间范围内
        if(queryTime >= orders[i].start && queryTime <= orders[i].leave) {
            result[count++] = orders[i].id;
        }
    }
    
    // 对结果排序
    sort(result, result + count);
    
    // 输出结果
    if(count == 0) {
        cout << "null" << endl;
    } else {
        for(int i = 0; i < count; i++) {
            cout << result[i] << endl;
        }
    }
    
    return 0;
}

import java.util.*;

public class Main {
    static class Order {
        int id;
        int start;
        int leave;
        
        Order(int id, int start, int leave) {
            this.id = id;
            this.start = start;
            this.leave = leave;
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int queryTime = sc.nextInt();
        
        Order[] orders = new Order[n];
        ArrayList<Integer> result = new ArrayList<>();
        
        // 读取订单信息
        for(int i = 0; i < n; i++) {
            int id = sc.nextInt();
            int start = sc.nextInt();
            int leave = sc.nextInt();
            orders[i] = new Order(id, start, leave);
            
            // 判断是否在时间范围内
            if(queryTime >= start && queryTime <= leave) {
                result.add(id);
            }
        }
        
        // 对结果排序
        Collections.sort(result);
        
        // 输出结果
        if(result.isEmpty()) {
            System.out.println("null");
        } else {
            for(int id : result) {
                System.out.println(id);
            }
        }
        
        sc.close();
    }
}

class Order:
    def __init__(self, id, start, leave):
        self.id = id
        self.start = start
        self.leave = leave

def main():
    n = int(input())
    query_time = int(input())
    
    result = []
    
    # 读取订单信息
    for _ in range(n):
        id, start, leave = map(int, input().split())
        # 判断是否在时间范围内
        if query_time >= start and query_time <= leave:
            result.append(id)
    
    # 对结果排序
    result.sort()
    
    # 输出结果
    if not result:
        print("null")
    else:
        for id in result:
            print(id)

if __name__ == "__main__":
    main()

算法及复杂度

  • 算法：排序
  • 时间复杂度： - 主要是排序的时间复杂度
  • 空间复杂度： - 需要存储订单信息和结果