账号名啥来着？

答案来自DeepSeek-R1（看！不！懂！） 以下是使用贪心算法（Johnson法则）解决流水车间调度问题的Python代码：

def main():
    n = int(input().strip())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))
    
    # 创建产品列表，每个元素为(产品编号, A时间, B时间)
    products = [(i + 1, a, b) for i, (a, b) in enumerate(zip(A, B))]
    
    # 分组处理
    group1 = []  # A <= B 的产品
    group2 = []  # A > B 的产品
    for p in products:
        if p[1] <= p[2]:
            group1.append(p)
        else:
            group2.append(p)
            
    # 对第一组按A时间升序排序
    group1_sorted = sorted(group1, key=lambda x: x[1])
    # 对第二组按B时间降序排序
    group2_sorted = sorted(group2, key=lambda x: x[2], reverse=True)
    
    # 合并两组：第一组在前，第二组在后
    order = group1_sorted + group2_sorted
    
    # 计算总加工时间
    timeA = 0
    timeB = 0
    for product in order:
        timeA += product[1]  # 累加A车间时间
        # B车间开始时间为max(当前A车间完成时间, 上一个B车间完成时间)
        timeB = max(timeA, timeB) + product[2]
    
    # 输出结果
    print(timeB)
    print(" ".join(str(product[0]) for product in order))

if __name__ == '__main__':
    main()

代码解释：

1. 输入处理：读取产品数量 n，A车间加工时间列表 A，B车间加工时间列表 B。
2. 产品分组：
   • 第一组（group1）：A车间时间 ≤ B车间时间的产品，按A时间升序排序。
   • 第二组（group2）：A车间时间 > B车间时间的产品，按B时间降序排序。
3. 合并序列：将第一组放在前面，第二组放在后面，形成最优加工顺序。
4. 时间计算：
   • timeA 记录A车间累计完成时间。
   • timeB 记录B车间累计完成时间（需等待A车间完成且B车间空闲）。
5. 输出结果：
   • 第一行：总加工时间（即最终的 timeB）。
   • 第二行：最优加工顺序（产品编号序列）。

样例验证：

输入：

5
3 5 8 7 10
6 2 1 4 9

输出：

34
1 5 4 2 3

计算过程：

1. 分组：
   • 产品1：(3,6) → A≤B → 第一组
   • 产品2：(5,2) → A>B → 第二组
   • 产品3：(8,1) → A>B → 第二组
   • 产品4：(7,4) → A>B → 第二组
   • 产品5：(10,9) → A>B → 第二组
   • 第一组排序：[产品1]
   • 第二组按B降序：[产品5(B=9), 产品4(B=4), 产品2(B=2), 产品3(B=1)]
2. 合并序列：[1, 5, 4, 2, 3]
3. 时间模拟：
   • 产品1：A=3 → timeA=3, B=6 → timeB=3+6=9
   • 产品5：A=10 → timeA=13, B=9 → timeB=max(13,9)+9=22
   • 产品4：A=7 → timeA=20, B=4 → timeB=max(20,22)+4=26
   • 产品2：A=5 → timeA=25, B=2 → timeB=max(25,26)+2=28
   • 产品3：A=8 → timeA=33, B=1 → timeB=max(33,28)+1=34

此算法时间复杂度为O(n log n)，符合贪心算法要求。