2492. Minimum Score of a Path Between Two Cities

You are given a positive integer n representing n cities numbered from 1 to n. You are also given a 2D array roads where roads[i] = [ai, bi, distancei] indicates that there is a bidirectional road between cities ai and bi with a distance equal to distancei. The cities graph is not necessarily connected.

The score of a path between two cities is defined as the minimum distance of a road in this path.

Return the minimum possible score of a path between cities 1 and n.

Note:

• A path is a sequence of roads between two cities.
• It is allowed for a path to contain the same road multiple times, and you can visit cities 1 and n multiple times along the path.
• The test cases are generated such that there is at least one path between 1 and n.

Example 1:

Input: n = 4, roads = [[1,2,9],[2,3,6],[2,4,5],[1,4,7]]
Output: 5
Explanation: The path from city 1 to 4 with the minimum score is: 1 -> 2 -> 4. The score of this path is min(9,5) = 5.
It can be shown that no other path has less score.

Example 2:

Input: n = 4, roads = [[1,2,2],[1,3,4],[3,4,7]]
Output: 2
Explanation: The path from city 1 to 4 with the minimum score is: 1 -> 2 -> 1 -> 3 -> 4. The score of this path is min(2,2,4,7) = 2.

Constraints:

• 2 <= n <= 105
• 1 <= roads.length <= 105
• roads[i].length == 3
• 1 <= ai, bi <= n
• ai != bi
• 1 <= distancei <= 104
• There are no repeated edges.
• There is at least one path between 1 and n.

Solution:

class Solution {
    int result;
    public int minScore(int n, int[][] roads) {
        Map<Integer, List<int[]>> graph = new HashMap<>();
        for (int i = 1; i <= n; i++){
            graph.put(i, new ArrayList<>());
        }

        for (int[] r : roads){
            int from = r[0];
            int to = r[1];
            int val = r[2];
            graph.get(from).add(new int[]{to, val});
            graph.get(to).add(new int[]{from, val});
        }

        Set<Integer> visited = new HashSet<>();
        result = Integer.MAX_VALUE; // 全局变量 不用在dfs中传递 不然会出错
        dfs(1, graph, visited);

        return result;
    }

    private void dfs(int i, Map<Integer, List<int[]>> graph, Set<Integer> visited){
        if (visited.contains(i)){
            return;
        }
        visited.add(i);
        List<int[]> nei = graph.get(i);

        for (int[] next : nei){
            int ne = next[0];
            int neVal = next[1];

            result = Math.min(neVal, result);

            dfs(ne, graph, visited);
        }

        return;
    }
}

// TC: O(n)
// SC: O(n)

class Solution {
    public int minScore(int n, int[][] roads) {
        Map<Integer, List<int[]>> graph = new HashMap<>();
        for (int i = 1; i <= n; i++){
            graph.put(i, new ArrayList<>());
        }

        for (int[] r : roads){
            int from = r[0];
            int to = r[1];
            int val = r[2];
            graph.get(from).add(new int[]{to, val});
            graph.get(to).add(new int[]{from, val});
        }

        Set<Integer> visited = new HashSet<>();
        int[] minScore = {Integer.MAX_VALUE};
        dfs(1, graph, visited, minScore);

        return minScore[0];
    }

    private void dfs(int city, Map<Integer, List<int[]>> graph, Set<Integer> visited, int[] minScore){
        visited.add(city);

        for (int[] nei : graph.get(city)){
            int next = nei[0];
            int val = nei[1];
            minScore[0] = Math.min(minScore[0], val);
            if (!visited.contains(next)){
                dfs(next, graph, visited, minScore);
            }
        }
    }
}