11.15华为OD机试真题 新系统 - 流水线最短总时间 (Java/Py/C/C++/Js/Go)

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

流水线最短总时间

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],&times); 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]]

在这里插入图片描述

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

算法大师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址