Question

给出“ n”个线程和“ m”个工作，它们需要花费不同的时间来完成。如果有空闲线程，它将立即从列表中获取下一个作业。如果线程已开始处理作业，则它不会中断或停止，直到完成处理作业为止。如果多个线程尝试同时从列表中获取作业，则索引较小的线程将接受该作业。

为每个作业确定将由哪个线程处理以及何时开始处理。

输入：

Newtonsoft.Json (= 9.0.1)

输出：

.NetFramework 4.6

我的代码：

2 5 # n m
1 2 3 4 5 # ? integers ?? — the times in seconds it takes any thread to process the ?-the job.

它通过了上述示例案例，但在其他案例上失败了。

测试用例输入失败：

0 0  # worker starting_time
1 0
0 1
1 2
0 4

预期输出：

from collections import namedtuple

AssignedJob = namedtuple("AssignedJob", ["worker", "started_at"])

def heapify(arr, i=0):# MIN HEAP

  #  0 --> time, 1 --> worker

  smallest = i
  l = 2*i + 1 # left child of node i
  r = 2*i + 2 # right child of node i

  if l < len(arr)  and arr[l][0] < arr[smallest][0]:
    smallest = l

  if r < len(arr)  and arr[r][0] < arr[smallest][0]:
    smallest = r
  
  if smallest != i:

    arr[i], arr[smallest] = arr[smallest], arr[i]
    heapify(arr, smallest)

  return arr[0][1] # worker whose time is lowest (top of min-heap)


def assign_jobs(n_workers, jobs):

    result = []
    next_free_time = [0] * n_workers

    for job in jobs:

        zip_time_workers = list(zip(next_free_time, [i for i in range(n_workers)]))
        #list of tuples --> (time, worker)

        next_worker = heapify(zip_time_workers)
        # get worker with highest priority

        result.append(AssignedJob(next_worker, next_free_time[next_worker]))
        next_free_time[next_worker] += job

    return result


def main():
    n_workers, n_jobs = map(int, input().split())
    jobs = list(map(int, input().split()))
    assert len(jobs) == n_jobs

    assigned_jobs = assign_jobs(n_workers, jobs)

    for job in assigned_jobs:
        print(job.worker, job.started_at)


if __name__ == "__main__":
    main()

我在做什么错？也欢迎更好的实现，谢谢！

编辑：不能将python的预定义函数用于优先级队列（需要基础逻辑/方法）

优先级队列（堆）实现并行处理

0 个答案: