悄悄话 - 华为OD统一考试

OD统一考试（C卷）

分值： 100分

题解： Java / Python / C++

alt

题目描述

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

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

输入描述

给定二叉树

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

注： -1 表示空节点

输出描述

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

示例1

输入：
0 9 20 -1 -1 15 15 7 -1 -1 -1 -1 3 2

输出：
38

题解

这个题目是一个树的遍历问题，采用**深度优先搜索（DFS）**的方式解决。

遍历时叶子节点最晚到达时间即为答案。

Java

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author code5bug
 */
public class Main {

    static int[] arr;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        arr = Arrays.stream(scanner.nextLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();

        System.out.println(dfs(0));
    }

    // 从 idx 节点到叶子节点最大耗时
    static int dfs(int idx) {
        int maxCostTime = 0;

        // 左右节点
        int leftIdx = 2 * idx + 1, rightIdx = 2 * idx + 2;
        if (leftIdx < arr.length && arr[leftIdx] != -1) {
            maxCostTime = Math.max(maxCostTime, dfs(leftIdx));
        }

        if (rightIdx < arr.length && arr[rightIdx] != -1) {
            maxCostTime = Math.max(maxCostTime, dfs(rightIdx));
        }

        return arr[idx] + maxCostTime;
    }
}

Python

arr = list(map(int, input().split()))
n = len(arr)

def dfs(idx):
    global n
    max_cost_time = 0
	
    # 左右节点
    left_idx, right_idx = 2 * idx + 1, 2 * idx + 2
    if left_idx < n and arr[left_idx] != -1:
        max_cost_time = max(max_cost_time, dfs(left_idx))
    if right_idx < n and arr[right_idx] != -1:
        max_cost_time = max(max_cost_time, dfs(right_idx))

    return arr[idx] + max_cost_time


print(dfs(0))

C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> arr;

// 从 idx 节点到叶子节点最大耗时
int dfs(int idx) {
    int maxCostTime = 0;

    // 左右节点
    int leftIdx = 2 * idx + 1, rightIdx = 2 * idx + 2;
    if (leftIdx < arr.size() && arr[leftIdx] != -1) {
        maxCostTime = max(maxCostTime, dfs(leftIdx));
    }

    if (rightIdx < arr.size() && arr[rightIdx] != -1) {
        maxCostTime = max(maxCostTime, dfs(rightIdx));
    }

    return arr[idx] + maxCostTime;
}

int main() {

    int num;
    while (cin >> num) {
        arr.push_back(num);
    }

    cout << dfs(0) << endl;

    return 0;
}