[HOT 100] 2646. 最小化旅行的价格总和

1. 题目链接

2646. 最小化旅行的价格总和 - 力扣（LeetCode）

2. 题目描述

现有一棵无向、无根的树，树中有 n 个节点，按从 0 到 n - 1 编号。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条边。

每个节点都关联一个价格。给你一个整数数组 price ，其中 price[i] 是第 i 个节点的价格。

给定路径的 价格总和 是该路径上所有节点的价格之和。

另给你一个二维整数数组 trips ，其中 trips[i] = [starti, endi] 表示您从节点 starti 开始第 i 次旅行，并通过任何你喜欢的路径前往节点 endi 。

在执行第一次旅行之前，你可以选择一些 非相邻节点 并将价格减半。

返回执行所有旅行的最小价格总和。

3. 题目示例

示例 1 :

输入：n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]]
输出：23
解释：
上图表示将节点 2 视为根之后的树结构。第一个图表示初始树，第二个图表示选择节点 0 、2 和 3 并使其价格减半后的树。
第 1 次旅行，选择路径 [0,1,3] 。路径的价格总和为 1 + 2 + 3 = 6 。
第 2 次旅行，选择路径 [2,1] 。路径的价格总和为 2 + 5 = 7 。
第 3 次旅行，选择路径 [2,1,3] 。路径的价格总和为 5 + 2 + 3 = 10 。
所有旅行的价格总和为 6 + 7 + 10 = 23 。可以证明，23 是可以实现的最小答案。

示例 2 :

输入：n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]]
输出：1
解释：
上图表示将节点 0 视为根之后的树结构。第一个图表示初始树，第二个图表示选择节点 0 并使其价格减半后的树。 
第 1 次旅行，选择路径 [0] 。路径的价格总和为 1 。 
所有旅行的价格总和为 1 。可以证明，1 是可以实现的最小答案。

4. 解题思路

1. 问题理解：
   • 给定一棵树，每个节点有一个价格。
   • 多个旅行路径（trips），每个路径从起点到终点。
   • 可以选择将某些节点的价格减半，但相邻节点不能同时减半。
   • 目标是最小化所有旅行路径的总价格。
2. 关键步骤：
   • 统计节点访问次数：通过DFS遍历每个trip的路径，统计每个节点被访问的次数。
   • 动态规划计算最小总价格：类似"打家劫舍III"问题，对每个节点有两种选择（减半或不变），需要满足相邻节点不能同时减半的条件。
3. DFS统计访问次数：
   • 对每个trip，从起点DFS到终点，标记路径上的所有节点。
   • 使用cnt数组记录每个节点被访问的总次数。
4. 动态规划设计：
   • 状态定义：dp(x)返回一个数组[notHalve, halve]，表示节点x不减半或减半时的最小总价格。
   • 状态转移：
     • 如果x不减半，子节点可以减半或不变，取最小值。
     • 如果x减半，子节点必须不减半。
   • 初始化：叶子节点的notHalve和halve直接计算。

5. 题解代码

class Solution {
    private List<Integer>[] g;  // 邻接表存储树结构
    private int[] price, cnt;    // price: 节点价格数组, cnt: 节点访问次数数组
    private int end;             // 当前trip的目标节点

    public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {
        // 初始化邻接表
        g = new ArrayList[n];
        Arrays.setAll(g, e -> new ArrayList<>());
        for (int[] e : edges) {
            int x = e[0], y = e[1];
            g[x].add(y);
            g[y].add(x);
        }

        // 初始化节点访问次数数组
        cnt = new int[n];
        // 处理每个trip，统计路径上的节点访问次数
        for (int[] t : trips) {
            end = t[1];
            dfs(t[0], -1);
        }

        this.price = price;
        // 动态规划计算最小总价格
        int[] res = dp(0, -1);
        return Math.min(res[0], res[1]);
    }

    // DFS统计trip路径上的节点访问次数
    private boolean dfs(int x, int fa) {
        if (x == end) {
            cnt[x]++;
            return true; // 找到目标节点
        }
        for (int y : g[x]) {
            if (y != fa && dfs(y, x)) {
                cnt[x]++; // 当前节点在路径上
                return true;
            }
        }
        return false; // 未找到目标节点
    }

    // 动态规划计算最小总价格（类似打家劫舍III）
    private int[] dp(int x, int fa) {
        int notHalve = price[x] * cnt[x]; // 当前节点价格不减半的总价格
        int halve = notHalve / 2;         // 当前节点价格减半的总价格
        for (int y : g[x]) {
            if (y != fa) {
                int[] res = dp(y, x); // 子节点的计算结果
                notHalve += Math.min(res[0], res[1]); // 当前节点不减半，子节点可以减半或不变
                halve += res[0]; // 当前节点减半，子节点必须不变
            }
        }
        return new int[]{notHalve, halve};
    }
}

6. 复杂度分析

时间复杂度：

• DFS统计访问次数：O(n * m)，其中n是节点数，m是trip数量（每个trip最坏O(n)）。
• 动态规划：O(n)，每个节点处理一次。
• 总时间复杂度：O(n * m + n) = O(n * m)。

空间复杂度：

• 邻接表：O(n)。
• cnt数组：O(n)。
• 递归调用栈：最坏O(n)。
• 总空间复杂度：O(n)。