有6个设计师，20个任务，所需时间分别是2, 2, 3, 3, 4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11，任务完成后需要进行审查，审查时间分别是1,1,2,2,3,3,2,2,4,4,6,6,1,1,2,3,1,5,3,2，在任务进行审查时，设计师可以进行别的任务，使用c语言求完成所有任务并审查结束的最小时间和设计师的工作方案。
尝试过暴力枚举和DFS，好像时间会特别长，请问哪位大佬有别的方法可以解决该问题吗，如果有代码就更好了
方案来自 梦想橡皮擦 狂飙组基于 GPT 编写的 “程秘”
可以使用贪心算法或者费用流算法来解决该问题。
贪心算法的做法是，把所有任务按照需要完成的时间从小到大排序，然后依次把每个任务分配给任务需要时间最短的设计师，让他去完成这个任务，如果此时此设计师已经有任务在进行，那么就在他完成当前任务后再分配这个任务。
费用流算法的做法是，把所有任务视为一个点，把所有设计师看作是另一个点，建立源点S和汇点T，把S向每个任务点连一条流量为1，费用为该任务的完成时间的边，把每个任务点向该任务的审查点连一条流量为1，费用为该任务的审查时间的边，把审查点向每个设计师连一条流量为1，费用为0的边，把每个设计师向T连一条流量为1，费用为0的边，最后跑一遍最小费用最大流算法，算出总费用就是完成所有任务并审查结束的最小时间。
import networkx as nx
import numpy as np
def get_min_time(designers, tasks, review_times):
n = len(designers)
m = len(tasks)
source, sink = 0, 2 * m + 1
G = nx.DiGraph()
for i in range(m):
G.add_edge(source, i + 1, capacity=1, weight=tasks[i])
G.add_edge(i + m + 1, sink, capacity=1, weight=review_times[i])
for j in range(n):
G.add_edge(i + 1, j + m + 1, capacity=1, weight=0)
return nx.min_cost_flow_cost(G, source, sink)
designers = [1, 2, 3, 4, 5, 6]
tasks = [2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11]
review_times = [1, 1, 2, 2, 3, 3, 2, 2, 4, 4, 6, 6, 1, 1, 2, 3, 1, 5, 3, 2]
print(get_min_time(designers, tasks, review_times))
用贪心算法
1.将任务的完成时间和审查时间分别排序。
2.选择完成时间最短的任务，如果有多个，则选择审查时间最短的任务。将该任务分配给空闲的设计师进行完成。
3.当任务完成后，该设计师可以开始进行审查，同时可以继续完成其他任务。
4.重复步骤2和3，直到所有任务都已经完成。
```c
#include<bits/stdc++.h>
using namespace std;
const int N=100;
int n=20,m=6;
int a[N],b[N],c[N];
bool cmp(int x,int y)
{
if(a[x]!=a[y]) return a[x]<a[y];
return b[x]<b[y];
}
int main()
{
int i,j,k=0,sum=0;
for(i=0;i<n;i++)
{
cin>>a[i];
}
for(i=0;i<n;i++)
{
cin>>b[i];
}
for(i=0;i<n;i++) c[i]=i;
sort(c,c+n,cmp);
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
if(b[c[i]]<=sum)
{
k=j;
break;
}
}
if(j==m) k=-1;
if(k==-1)
{
m++;
```