2065.最大化一张图中的路径价值

解题思路

枚举

枚举从0开始所有可能的路径，代码能力就是如何枚举，递归+回溯
递归函数：当前节点，当前路径总时间，节点的价值之和。对相联通的节点进行递归搜索，如果回到节点0，则更新。
超过总时间，则当前路径结束，回溯。
题目说每个节点至多有四条边与之相连，则对节点的遍历需要先对节点进行处理，存储得到每个节点与之连接的节点有哪些。即将edges转换成邻接表。

C++

class Solution {
public:
    int maximalPathQuality(vector<int>& values, vector<vector<int>>& edges, int maxTime) {
        // 时间有限制，根据时间找出满足时间的路径
        // 图的遍历方法
        // 实际上可以直接枚举所有路径，并更新
        // 获取节点数量
        int n = values.size();
        vector<vector<pair<int, int>>> g(n);
        for (const auto & edge : edges){
            g[edge[0]].emplace_back(edge[1], edge[2]);
            g[edge[1]].emplace_back(edge[0], edge[2]);

        }
        vector<int> visited(n);
        visited[0] = true;
        int ans = 0;
        function<void(int, int, int)> dfs = [&](int u, int time, int value){
            // 判断是否回到0
            if (u == 0){
                // 更新
                ans = max(ans, value);
            }
            // 从当前节点寻找联通的
            for (const auto& [v, dist]:g[u]){
                if ((time + dist) <= maxTime){
                    if (!visited[v]){
                        // v节点没有被访问过
                        visited[v] = true;
                        dfs(v, time+dist, value + values[v]);
                        visited[v] = false;
                    }else{
                        dfs(v, time+dist, value); // v节点访问过了，价值就可以不重复加
                    }
                }
            }
        };
        dfs(0, 0, values[0]);
        return ans;
    }
};

python

class Solution:
    def maximalPathQuality(self, values: List[int], edges: List[List[int]], maxTime: int) -> int:
        # 节点数量
        n = len(values)
        # 创建
        g = defaultdict(list)
        for x, y, z in edges:
            g[x].append((y,z))
            g[y].append((x,z))
        visited = {0}
        ans = 0
        def dfs(u:int, time:int, value:int)->None:
            if u ==0:
                nonlocal ans
                ans = max(ans, value)
            for v, dist in g[u]:
                if time+dist <= maxTime:
                    if v not in visited:
                        visited.add(v)
                        dfs(v, time+dist, value + values[v])
                        visited.discard(v)
                    else:
                        dfs(v, time+dist, value)
        dfs(0,0,values[0])
        return ans

java

class Solution {
    int ans = 0;
    int[] values;
    int maxTime;
    List<int[]>[] g;
    boolean[] visited;

    public int maximalPathQuality(int[] values, int[][] edges, int maxTime) {
        this.values = values;
        this.maxTime = maxTime;
        int n = values.length;
        g = new List[n];
        for (int i = 0; i < n; i++) {
            g[i] = new ArrayList<int[]>();
        }
        for (int[] edge : edges) {
            g[edge[0]].add(new int[]{edge[1], edge[2]});
            g[edge[1]].add(new int[]{edge[0], edge[2]});
        }

        visited = new boolean[n];
        visited[0] = true;
        
        dfs(0, 0, values[0]);
        return ans;
    }

    public void dfs(int u, int time, int value) {
        if (u == 0) {
            ans = Math.max(ans, value);
        }
        for (int[] arr : g[u]) {
            int v = arr[0], dist = arr[1];
            if (time + dist <= maxTime) {
                if (!visited[v]) {
                    visited[v] = true;
                    dfs(v, time + dist, value + values[v]);
                    visited[v] = false;
                } else {
                    dfs(v, time + dist, value);
                }
            }
        }
    }
}