【华为OD】机试真题 - 最富裕的小家庭 - 2024年D卷

题目描述
在一颗树中，每个节点代表一个家庭成员，节点的数字表示其个人的财富值，一个节点及其直接相连的子节点被定义为一个小家庭。
现给你一颗树，请计算出最富裕的小家庭的财富和。
输入描述
第一行为一个数 N，表示成员总数，成员编号 1~N。1 ≤ N ≤ 1000
第二行为 N 个空格分隔的数，表示编号 1~N 的成员的财富值。0 ≤ 财富值 ≤ 1000000
接下来 N -1 行，每行两个空格分隔的整数（N1, N2），表示 N1 是 N2 的父节点。
输出描述
最富裕的小家庭的财富和
测试用例

输入：4 100 200 300 500 1 2 1 3 2 4
输出：700
说明：
1. 首先，根据输入的父子关系构建树结构。
2. 然后，遍历树的每个节点，计算以该节点为根的子树的财富和。
3. 在遍历过程中，记录最大的财富和。
4. 最后，输出最大财富和。

---

Python 解法：

def dfs(node, tree, wealth, visited):
    visited[node] = True
    total_wealth = wealth[node]
    for child in tree[node]:
        if not visited[child]:
            total_wealth += wealth[child]
    return total_wealth


def find_richest_family(N, wealth, edges):
    # 构建树的邻接表
    tree = [[] for _ in range(N)]
    for parent, child in edges:
        tree[parent - 1].append(child - 1)
        tree[child - 1].append(parent - 1)

    visited = [False] * N
    max_wealth = 0

    for i in range(N):
        if not visited[i]:
            family_wealth = dfs(i, tree, wealth, visited)
            max_wealth = max(max_wealth, family_wealth)
    return max_wealth


if __name__ == "__main__":
    data = input().split()

    N = int(data[0])
    wealth = list(map(int, data[1:N + 1]))
    edges = [tuple(map(int, data[i:i + 2])) for i in range(N + 1, len(data), 2)]

    result = find_richest_family(N, wealth, edges)
    print(result)

Java 解法：

import java.util.*;

public class RichestFamily {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取成员总数
        int N = scanner.nextInt();
        // 读取成员的财富值
        int[] wealth = new int[N];
        for (int i = 0; i < N; i++) {
            wealth[i] = scanner.nextInt();
        }

        // 构建树的邻接表
        List<List<Integer>> tree = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            tree.add(new ArrayList<>());
        }

        // 读取边并构建树
        for (int i = 0; i < N - 1; i++) {
            int parent = scanner.nextInt() - 1;
            int child = scanner.nextInt() - 1;
            tree.get(parent).add(child);
            tree.get(child).add(parent);
        }
        scanner.close();

        // 计算每个小家庭的财富和
        boolean[] visited = new boolean[N];
        int maxWealth = 0;

        for (int i = 0; i < N; i++) {
            if (!visited[i]) {
                int familyWealth = dfs(i, tree, wealth, visited);
                maxWealth = Math.max(maxWealth, familyWealth);
            }
        }
        // 输出结果
        System.out.println(maxWealth);
    }

    private static int dfs(int node, List<List<Integer>> tree, int[] wealth, boolean[] visited) {
        visited[node] = true;
        int totalWealth = wealth[node];

        for (int child : tree.get(node)) {
            if (!visited[child]) {
                totalWealth += wealth[child];
            }
        }
        return totalWealth;
    }
}

C++ 解法：

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

using namespace std;

int dfs(int node, const vector<vector<int>>& tree, const vector<int>& wealth, vector<bool>& visited) {
    visited[node] = true;
    int totalWealth = wealth[node];

    for (int child : tree[node]) {
        if (!visited[child]) {
            totalWealth += wealth[child];
        }
    }
    return totalWealth;
}

int findRichestFamily(int N, const vector<int>& wealth, const vector<pair<int, int>>& edges) {
    // 构建树的邻接表
    vector<vector<int>> tree(N);
    for (const auto& edge : edges) {
        int parent = edge.first - 1;
        int child = edge.second - 1;
        tree[parent].push_back(child);
        tree[child].push_back(parent);
    }

    vector<bool> visited(N, false);
    int maxWealth = 0;

    for (int i = 0; i < N; ++i) {
        if (!visited[i]) {
            int familyWealth = dfs(i, tree, wealth, visited);
            maxWealth = max(maxWealth, familyWealth);
        }
    }
    return maxWealth;
}

int main() {
    int N;
    cin >> N;

    vector<int> wealth(N);
    for (int i = 0; i < N; ++i) {
        cin >> wealth[i];
    }

    vector<pair<int, int>> edges(N - 1);
    for (int i = 0; i < N - 1; ++i) {
        int parent, child;
        cin >> parent >> child;
        edges[i] = {parent, child};
    }

    int result = findRichestFamily(N, wealth, edges);
    cout << result << endl;

    return 0;
}

+++==========================================================+++
以上内容仅为个人学习记录使用。
如有转载，请附有原文出处链接。

牛客网原题链接：https://www.nowcoder.com/discuss/635262849660534784?sourceSSR=search