流水线最短总时间
2026 华为OD机试真题11月15日华为OD上机新系统考试真题 100 分题型
点击查看华为 OD 机试真题完整目录:2026最新华为OD机试新系统卷 + 双机位C卷 真题题库目录|全覆盖题库 + 逐点算法考点详解
题目描述
在企业数据中台或自动化构建系统中,一个大型任务集由成百上千个子任务组成。
有的任务之间存在严格依赖关系,为提升效率,没有相互依赖关系的任务将会被系统并行(同时)执行。
你需要编写一个算法:在给定所有任务的执行时间,以及它们之间的依赖关系后,评估出整个数据流水线完全运行结束所需的最短总时间。
输入描述
- t i m e s times times:一个二维数组,其中 t i m e s [ i ] = [ t a s k _ i d , d u r a t i o n ] times[i]=[task\_id, duration] times[i]=[task_id,duration],表示任务 t a s k _ i d task\_id task_id 执行所需的耗时为 d u r a t i o n duration duration 分钟。
- d e p e n d e n c i e s dependencies dependencies:一个二维数组,其中 d e p e n d e n c i e s [ i ] = [ A , B ] dependencies[i]=[A,B] dependencies[i]=[A,B] 表示任务 A A A 必须在任务 B B B 开始之前完成;输入保证不存在环形依赖。
数据范围:
- 1 ≤ n ≤ 10 4 1 \le n \le 10^4 1≤n≤104, n n n 为 t i m e s times times 的长度,任务编号 t a s k _ i d task\_id task_id 为 1 ∼ n 1 \sim n 1∼n 且互不相同
- 1 ≤ d u r a t i o n ≤ 10 4 1 \le duration \le 10^4 1≤duration≤104
- 0 ≤ d e p e n d e n c i e s . l e n g t h ≤ 10 5 0 \le dependencies.length \le 10^5 0≤dependencies.length≤105, 1 ≤ A , B ≤ n 1 \le A,B \le n 1≤A,B≤n, A ≠ B A \ne B A=B
输出描述
请计算完成给定任务的最少时间。
示例1
输入
[[1, 3], [2, 2], [3, 5], [4, 1], [5, 4]],[[1, 3],[2, 3], [3, 4], [3, 5]]
输出
12
说明
- 任务 1 1 1 和 2 2 2 没有任何前置依赖,它们在第 0 0 0 分钟同时并行启动。
- 任务 2 2 2 在第 2 2 2 分钟完成,但任务 3 3 3 还需要等待任务 1 1 1(耗时 3 3 3 分钟)完成。
- 任务 3 3 3 在第 3 3 3 分钟启动,并在第 8 8 8 分钟( 3 + 5 3+5 3+5)完成。
- 任务 4 4 4 和 5 5 5 在第 8 8 8 分钟同时并行启动。
- 任务 4 4 4 在第 9 9 9 分钟完成,任务 5 5 5 在第 12 12 12 分钟( 8 + 4 8+4 8+4)完成。
- 整个流水线的瓶颈在任务 5 5 5,所以总耗时为 12 12 12。
示例2
输入
[[1, 10], [2, 5], [3, 8]],[]
输出
10
说明
- 没有任何前置条件,任务 1 1 1、 2 2 2、 3 3 3 在第 0 0 0 分钟同时并行启动。
- 任务 2 2 2 在第 5 5 5 分钟完成。
- 任务 3 3 3 在第 8 8 8 分钟完成。
- 任务 1 1 1 在第 10 10 10 分钟完成。
- 这批任务的总耗时仅仅取决于耗时最长的那单个任务(即任务 1 1 1),所以总耗时为 10 10 10。
解题思路
本题采用【拓扑排序与动态规划】算法:将依赖 [A,B] 建为 A 指向 B 的边,按照前置任务全部完成后才能启动后继的规则计算时间。
按任务编号保存耗时,初始完成时间设为任务自身耗时。把入度为零的任务加入队列,它们都可以从零时刻开始。处理任务时,用它的完成时间加上后继耗时,更新后继的最早完成时间。
存在多个前驱时,后继必须等待最晚完成的前驱,因此更新时取最大值。每条边处理后减少后继入度,降为零再入队。最终取所有任务完成时间的最大值,就包含了各条并行分支所需的总时间。
Java
import java.util.*;
public class Main {
static int solve(int[][] times, int[][] edges) {
int n=times.length;
int[] duration=new int[n+1], finish=new int[n+1], degree=new int[n+1], queue=new int[n];
List<List<Integer>> graph=new ArrayList<>();
for (int i=0; i<=n; i++) graph.add(new ArrayList<>());
// 按实际编号保存耗时,初始完成时间等于自身耗时。
for (int[] row:times) duration[row[0]]=finish[row[0]]=row[1];
for (int[] row:edges) { graph.get(row[0]).add(row[1]); degree[row[1]]++; }
int head=0, tail=0, best=0;
for (int i=1; i<=n; i++) if (degree[i]==0) queue[tail++]=i;
while (head<tail) {
int u=queue[head++];
best=Math.max(best,finish[u]);
for (int v:graph.get(u)) {
// 等待全部前驱中的最晚完成者。
finish[v]=Math.max(finish[v],finish[u]+duration[v]);
if (--degree[v]==0) queue[tail++]=v;
}
}
return best;
}
static List<String> parts(String text) {
List<String> result = new ArrayList<>();
int depth=0, start=0;
for (int i=0; i<text.length(); i++) {
char ch=text.charAt(i);
if (ch=='[') depth++;
if (ch==']') depth--;
if (ch==',' && depth==0) {
result.add(text.substring(start,i).trim()); start=i+1;
}
}
if (!text.substring(start).trim().isEmpty()) result.add(text.substring(start).trim());
return result;
}
static int[] array(String text) {
String body=text.trim();
body=body.substring(1,body.length()-1).trim();
if (body.isEmpty()) return new int[0];
String[] values=body.split(",");
int[] result=new int[values.length];
for (int i=0; i<values.length; i++) result[i]=Integer.parseInt(values[i].trim());
return result;
}
static int[][] matrix(String text) {
String body=text.trim();
List<String> rows=parts(body.substring(1,body.length()-1));
int[][] result=new int[rows.size()][];
for (int i=0; i<rows.size(); i++) result[i]=array(rows.get(i));
return result;
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
List<String> p=parts(scanner.nextLine());
System.out.println(solve(matrix(p.get(0)), matrix(p.get(1))));
}
}
Python
import json
def solve(times, edges):
n = len(times)
duration = [0] * (n+1)
graph = [[] for _ in range(n+1)]
degree = [0] * (n+1)
finish = [0] * (n+1)
# 耗时按任务编号保存,输入行顺序不代表任务顺序。
for task, cost in times:
duration[task] = cost
finish[task] = cost
for a, b in edges:
graph[a].append(b)
degree[b] += 1
queue = [task for task in range(1,n+1) if degree[task] == 0]
head = best = 0
while head < len(queue):
task = queue[head]
head += 1
best = max(best, finish[task])
for nxt in graph[task]:
# 后继必须等待最晚完成的前置任务。
finish[nxt] = max(finish[nxt], finish[task]+duration[nxt])
degree[nxt] -= 1
if degree[nxt] == 0:
queue.append(nxt)
return best
def main():
args = json.loads("[" + input() + "]")
result = solve(*args)
print(json.dumps(result, separators=(",", ":")))
if __name__ == "__main__":
main()
JavaScript
function solve(times, edges) {
const n=times.length, duration=Array(n+1).fill(0), finish=Array(n+1).fill(0);
const graph=Array.from({length:n+1},()=>[]), degree=Array(n+1).fill(0), queue=[];
// 编号与输入行位置分开处理。
for (const [id,cost] of times) duration[id]=finish[id]=cost;
for (const [a,b] of edges) { graph[a].push(b); degree[b]++; }
for (let id=1; id<=n; id++) if (!degree[id]) queue.push(id);
let best=0;
for (let head=0; head<queue.length; head++) {
const u=queue[head];
best=Math.max(best,finish[u]);
for (const v of graph[u]) {
// 后继完成时间取全部前驱贡献的最大值。
finish[v]=Math.max(finish[v],finish[u]+duration[v]);
if (--degree[v]===0) queue.push(v);
}
}
return best;
}
function main() {
const rl=require("readline").createInterface({input:process.stdin});
rl.once("line", line => {
const args=JSON.parse("["+line+"]");
console.log(JSON.stringify(solve(...args)));
rl.close();
});
}
main();
C++
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <algorithm>
#include <utility>
using namespace std;
vector<string> parts(const string& text) {
vector<string> out;
int depth=0, start=0;
for (int i=0; i<(int)text.size(); i++) {
if (text[i]=='[') depth++;
if (text[i]==']') depth--;
if (text[i]==',' && depth==0) { out.push_back(text.substr(start,i-start)); start=i+1; }
}
string last=text.substr(start);
if (last.find_first_not_of(" \t\r\n")!=string::npos) out.push_back(last);
return out;
}
vector<int> parseArray(string text) {
auto left=text.find('['), right=text.rfind(']');
vector<int> out;
for (const string& item:parts(text.substr(left+1,right-left-1))) out.push_back(stoi(item));
return out;
}
vector<vector<int>> parseMatrix(string text) {
auto left=text.find('['), right=text.rfind(']');
vector<vector<int>> out;
for (const string& row:parts(text.substr(left+1,right-left-1))) out.push_back(parseArray(row));
return out;
}
int solve(const vector<vector<int>>& times, const vector<vector<int>>& edges) {
int n=times.size();
vector<int> duration(n+1),finish(n+1),degree(n+1),queue;
vector<vector<int>> graph(n+1);
// 耗时按编号保存,根任务从零时刻开始。
for (const auto& row:times) duration[row[0]]=finish[row[0]]=row[1];
for (const auto& row:edges) { graph[row[0]].push_back(row[1]); degree[row[1]]++; }
for (int i=1; i<=n; i++) if (!degree[i]) queue.push_back(i);
int best=0;
for (size_t head=0; head<queue.size(); head++) {
int u=queue[head];
best=max(best,finish[u]);
for (int v:graph[u]) {
// 多条依赖汇合时选择最晚完成的前驱。
finish[v]=max(finish[v],finish[u]+duration[v]);
if (--degree[v]==0) queue.push_back(v);
}
}
return best;
}
int main() {
string line;
getline(cin,line);
auto p=parts(line);
auto result=solve(parseMatrix(p[0]), parseMatrix(p[1]));
cout << result << "\n";
return 0;
}
Go
package main
import (
"bufio"
"encoding/json"
"fmt"
"os"
)
func solve(times, edges [][]int) int {
n:=len(times)
duration,finish,degree:=make([]int,n+1),make([]int,n+1),make([]int,n+1)
graph:=make([][]int,n+1)
// 以编号存储,避免把输入行下标误当成任务编号。
for _, row:=range times { duration[row[0]]=row[1]; finish[row[0]]=row[1] }
for _, row:=range edges { graph[row[0]]=append(graph[row[0]],row[1]); degree[row[1]]++ }
queue:=make([]int,0,n)
for i:=1; i<=n; i++ { if degree[i]==0 { queue=append(queue,i) } }
best:=0
for head:=0; head<len(queue); head++ {
u:=queue[head]
if finish[u]>best { best=finish[u] }
for _,v:=range graph[u] {
// 最早完成时间由最慢前驱决定。
if candidate:=finish[u]+duration[v]; candidate>finish[v] { finish[v]=candidate }
degree[v]--
if degree[v]==0 { queue=append(queue,v) }
}
}
return best
}
func main() {
reader:=bufio.NewReader(os.Stdin)
line,_:=reader.ReadString('\n')
var args []json.RawMessage
if err:=json.Unmarshal([]byte("["+line+"]"),&args); err!=nil { return }
var times [][]int
if err:=json.Unmarshal(args[0],×); err!=nil { return }
var edges [][]int
if err:=json.Unmarshal(args[1],&edges); err!=nil { return }
result:=solve(times,edges)
output,_:=json.Marshal(result)
fmt.Println(string(output))
}
C语言
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
typedef struct { int *a; int n; } Ints;
typedef struct { Ints *a; int n; } Rows;
typedef struct { int key, order, count; } Item;
void skip(const char **p) { while (isspace((unsigned char)**p)) ++*p; }
void take(const char **p, char expected) {
skip(p);
if (**p != expected) exit(1);
++*p;
}
int number(const char **p) {
skip(p);
char *end;
long value=strtol(*p,&end,10);
if (end==*p) exit(1);
*p=end;
return (int)value;
}
Ints array(const char **p) {
Ints result={NULL,0};
int cap=8;
result.a=(int*)malloc((size_t)cap*sizeof(int));
take(p,'['); skip(p);
while (**p!=']') {
if (result.n==cap) { cap*=2; result.a=(int*)realloc(result.a,(size_t)cap*sizeof(int)); }
result.a[result.n++]=number(p); skip(p);
if (**p!=',') break;
take(p,',');
}
take(p,']');
return result;
}
Rows matrix(const char **p) {
Rows result={NULL,0};
int cap=8;
result.a=(Ints*)malloc((size_t)cap*sizeof(Ints));
take(p,'['); skip(p);
while (**p!=']') {
if (result.n==cap) { cap*=2; result.a=(Ints*)realloc(result.a,(size_t)cap*sizeof(Ints)); }
result.a[result.n++]=array(p); skip(p);
if (**p!=',') break;
take(p,',');
}
take(p,']');
return result;
}
void freeRows(Rows rows) {
for (int i=0; i<rows.n; i++) free(rows.a[i].a);
free(rows.a);
}
int compare(const void *left, const void *right) {
const Item *a=(const Item*)left, *b=(const Item*)right;
if (a->key!=b->key) return (a->key>b->key)-(a->key<b->key);
return (a->order>b->order)-(a->order<b->order);
}
int solve(Rows times, Rows edges) {
int n=times.n, m=edges.n;
int *duration=(int*)calloc((size_t)n+1,sizeof(int));
int *finish=(int*)calloc((size_t)n+1,sizeof(int));
int *degree=(int*)calloc((size_t)n+1,sizeof(int));
int *head=(int*)malloc(((size_t)n+1)*sizeof(int));
int *next=(int*)malloc((size_t)(m+1)*sizeof(int));
int *to=(int*)malloc((size_t)(m+1)*sizeof(int));
int *queue=(int*)malloc((size_t)n*sizeof(int));
// 链式邻接表在线性空间内保存所有依赖。
for (int i=0; i<=n; i++) head[i]=-1;
for (int i=0; i<n; i++) duration[times.a[i].a[0]]=finish[times.a[i].a[0]]=times.a[i].a[1];
for (int i=0; i<m; i++) {
int a=edges.a[i].a[0], b=edges.a[i].a[1];
to[i]=b; next[i]=head[a]; head[a]=i; degree[b]++;
}
int first=0,last=0,best=0;
for (int i=1; i<=n; i++) if (!degree[i]) queue[last++]=i;
while (first<last) {
int u=queue[first++];
if (finish[u]>best) best=finish[u];
for (int e=head[u]; e!=-1; e=next[e]) {
int v=to[e], candidate=finish[u]+duration[v];
// 后继必须等待全部前驱完成。
if (candidate>finish[v]) finish[v]=candidate;
if (--degree[v]==0) queue[last++]=v;
}
}
free(duration); free(finish); free(degree); free(head); free(next); free(to); free(queue);
return best;
}
int main(void) {
size_t size=0, cap=256;
char *line=(char*)malloc(cap);
int ch;
while ((ch=getchar())!=EOF && ch!='\n') {
if (size+1==cap) { cap*=2; line=(char*)realloc(line,cap); }
line[size++]=(char)ch;
}
line[size]='\0';
const char *p=line;
Rows times=matrix(&p);
take(&p,',');
Rows edges=matrix(&p);
int result=solve(times,edges);
printf("%d\n",result);
freeRows(times);
freeRows(edges);
free(line);
return 0;
}
完整用例
用例1
[[1, 3], [2, 2], [3, 5], [4, 1], [5, 4]],[[1, 3],[2, 3], [3, 4], [3, 5]]
用例2
[[1, 10], [2, 5], [3, 8]],[]
用例3
[[1,1]],[]
用例4
[[3,2],[1,4],[2,3]],[[1,2],[2,3]]
用例5
[[1,2],[2,7],[3,3]],[[1,3],[2,3]]
用例6
[[1,2],[2,3],[3,5],[4,1]],[[1,2],[1,3],[2,4],[3,4]]
用例7
[[1,8],[2,2],[3,3],[4,4]],[[2,3],[3,4]]
用例8
[[1,10000],[2,10000],[3,10000]],[[1,2],[2,3]]
用例9
[[4,1],[2,2],[3,3],[1,4]],[[1,2],[1,3],[1,4]]
用例10
[[1,2],[2,3],[3,1]],[[1,2],[1,3],[2,3]]

该博客解析华为OD机试真题‘流水线最短总时间’,核心是基于有向无环图(DAG)的拓扑排序与动态规划求解任务调度最短完成时间。给定任务执行时长及依赖关系(A→B表示A必须先于B完成),需计算所有任务执行完毕的最早时刻。算法通过入度统计、队列驱动的拓扑遍历,结合最早开始时间状态转移(取前驱最大完成时间),最终返回所有任务完成时间的最大值。
211

被折叠的 条评论
为什么被折叠?



