华为OD机试 2025 B卷 - 悄悄话 (C++ & Python & JAVA & JS & GO)

悄悄话

华为OD机试真题目录点击查看: 华为OD机试2025B卷真题题库目录｜机考题库 + 算法考点详解

华为OD机试2025B卷 100分题型

悄悄话

真题目录: 点击去查看

2025A卷 100分题型

题目描述

给定一个二叉树，每个节点上站一个人，节点[数字表示]父节点到该节点传递悄悄话需要花费的时间。

初始时，根节点所在位置的人有一个悄悄话想要传递给其他人，求二叉树所有节点上的人都接收到悄悄话花费的时间。

输入描述

给定二叉树

0 9 20 -1 -1 15 7 -1 -1 -1 -1 3 2

输出描述

返回所有节点都接收到悄悄话花费的时间

38

示例1

输入

0 9 20 -1 -1 15 7 -1 -1 -1 -1 3 2

输出

38

题解

思路：DFS

1. 这道题本质上是求从根节点到 叶子节点的最大路径和。
2. 根据输入的数据可以还原出二叉树，对于数组表示的二叉树，子节点和父节点的位置关系，例如父节点在数组中的索引为i,左子节点的索引为2 * (i + 1) -1, 右节点的索引为2 * (i +1 ).
3. 使用DFS遍历根节点到所有叶子节点(没有子节点的节点)的路径和，其中最大的和就是结果。

c++

#include
#include
#include
#include  
#include 
#include
using namespace std;
// 存储最大时间
int res = 0;
// 深度遍历
void dfs(int value, vector<int> tree, int pos) {
    int tmp = value + tree[pos];
    int left = 2 * (pos + 1) - 1;
    int right = 2 * (pos + 1);
    // 已经到达叶子节点，更新最大值
    if ((left >= tree.size() || tree[left] == -1) && (right >= tree.size() || tree[right] == -1)) {
        res = max(res, tmp);
        return;
    }  
    if (!(left >= tree.size() || tree[left] == -1)) {
        dfs(tmp, tree, left);
    } 
    
    if (!(right >= tree.size() || tree[right] == -1)) {
        dfs(tmp, tree, right);
    }
}

int main() {
    vector<int> tree;
    int tmp;
    while (cin >> tmp) {
        tree.push_back(tmp);
    }
    if (tree.size() == 0) {
        cout << res;
        return 0;
    }
    dfs(0,  tree, 0);
    cout << res;
    return 0;
}

Java

import java.util.*;

public class Main {
    // 存储最大时间
    static int res = 0;

    // 深度优先搜索（DFS）
    static void dfs(int value, List<Integer> tree, int pos) {
        int tmp = value + tree.get(pos);
        int left = 2 * (pos + 1) - 1;
        int right = 2 * (pos + 1);

        // 已到达叶子节点，更新最大值
        if ((left >= tree.size() || tree.get(left) == -1) && (right >= tree.size() || tree.get(right) == -1)) {
            res = Math.max(res, tmp);
            return;
        }
        if (left < tree.size() && tree.get(left) != -1) {
            dfs(tmp, tree, left);
        }
        if (right < tree.size() && tree.get(right) != -1) {
            dfs(tmp, tree, right);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<Integer> tree = new ArrayList<>();

        while (scanner.hasNextInt()) {
            tree.add(scanner.nextInt());
        }
        scanner.close();

        if (tree.isEmpty()) {
            System.out.println(res);
            return;
        }
        dfs(0, tree, 0);
        System.out.println(res);
    }
}

Python

import sys
# 存储最大时间
res = 0

# 深度优先搜索（DFS）
def dfs(value, tree, pos):
    global res
    tmp = value + tree[pos]
    left = 2 * (pos + 1) - 1
    right = 2 * (pos + 1)

    # 已到达叶子节点，更新最大值
    if (left >= len(tree) or tree[left] == -1) and (right >= len(tree) or tree[right] == -1):
        res = max(res, tmp)
        return

    if left < len(tree) and tree[left] != -1:
        dfs(tmp, tree, left)
    if right < len(tree) and tree[right] != -1:
        dfs(tmp, tree, right)

# 读取输入
tree = list(map(int, sys.stdin.read().split()))

if not tree:
    print(res)
else:
    dfs(0, tree, 0)
    print(res)

JavaScript

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let tree = [];
// 最大时间
let res = 0;

// 深度优先搜索（DFS）
function dfs(value, tree, pos) {
    let tmp = value + tree[pos];
    let left = 2 * (pos + 1) - 1;
    let right = 2 * (pos + 1);

    // 叶子节点
    if ((left >= tree.length || tree[left] === -1) && (right >= tree.length || tree[right] === -1)) {
        res = Math.max(res, tmp);
        return;
    }

    if (left < tree.length && tree[left] !== -1) {
        dfs(tmp, tree, left);
    }
    if (right < tree.length && tree[right] !== -1) {
        dfs(tmp, tree, right);
    }
}

// 读取输入
rl.on("line", (input) => {
    tree = input.split(" ").map(Number);
    if (tree.length === 0) {
        console.log(res);
    } else {
        dfs(0, tree, 0);
        console.log(res);
    }
    rl.close();
});

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)
// 最大时间
var res int

// 深度优先搜索（DFS）
func dfs(value int, tree []int, pos int) {
	tmp := value + tree[pos]
	left := 2*(pos+1) - 1
	right := 2 * (pos + 1)

	// 已到达叶子节点，更新最大值
	if (left >= len(tree) || tree[left] == -1) && (right >= len(tree) || tree[right] == -1) {
		if tmp > res {
			res = tmp
		}
		return
	}

	if left < len(tree) && tree[left] != -1 {
		dfs(tmp, tree, left)
	}
	if right < len(tree) && tree[right] != -1 {
		dfs(tmp, tree, right)
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	input := scanner.Text()

	// 解析输入
	parts := strings.Fields(input)
	tree := make([]int, len(parts))
	for i, s := range parts {
		tree[i], _ = strconv.Atoi(s)
	}

	if len(tree) == 0 {
		fmt.Println(res)
		return
	}

	dfs(0, tree, 0)
	fmt.Println(res)
}