2492. Minimum Score of a Path Between Two Cities

import java.util.*;

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

        for (int[] road : roads) {
            graph[road[0]].add(new int[]{road[1], road[2]});
            graph[road[1]].add(new int[]{road[0], road[2]});
        }

        boolean[] vis = new boolean[n + 1];
        Queue<Integer> q = new LinkedList<>();
        q.offer(1);
        vis[1] = true;

        int ans = Integer.MAX_VALUE;

        while (!q.isEmpty()) {
            int u = q.poll();

            for (int[] edge : graph[u]) {
                int v = edge[0];
                int d = edge[1];

                ans = Math.min(ans, d);

                if (!vis[v]) {
                    vis[v] = true;
                    q.offer(v);
                }
            }
        }

        return ans;
    }
}

from collections import deque

class Solution:
    def minScore(self, n: int, roads):

        graph = [[] for _ in range(n + 1)]

        for u, v, d in roads:
            graph[u].append((v, d))
            graph[v].append((u, d))

        vis = [False] * (n + 1)

        q = deque([1])
        vis[1] = True

        ans = float("inf")

        while q:

            u = q.popleft()

            for v, d in graph[u]:

                ans = min(ans, d)

                if not vis[v]:
                    vis[v] = True
                    q.append(v)

        return ans

class Solution {
public:
    int minScore(int n, vector<vector<int>>& roads) {

        vector<vector<pair<int,int>>> graph(n + 1);

        for(auto &r : roads){
            graph[r[0]].push_back({r[1], r[2]});
            graph[r[1]].push_back({r[0], r[2]});
        }

        vector<bool> vis(n + 1, false);

        queue<int> q;
        q.push(1);
        vis[1] = true;

        int ans = INT_MAX;

        while(!q.empty()){

            int u = q.front();
            q.pop();

            for(auto &[v,d] : graph[u]){

                ans = min(ans, d);

                if(!vis[v]){
                    vis[v] = true;
                    q.push(v);
                }
            }
        }

        return ans;
    }
};

var minScore = function(n, roads) {

    const graph = Array.from({length: n + 1}, () => []);

    for (const [u, v, d] of roads) {
        graph[u].push([v, d]);
        graph[v].push([u, d]);
    }

    const vis = new Array(n + 1).fill(false);

    const q = [1];
    vis[1] = true;

    let head = 0;
    let ans = Number.MAX_SAFE_INTEGER;

    while (head < q.length) {

        const u = q[head++];

        for (const [v, d] of graph[u]) {

            ans = Math.min(ans, d);

            if (!vis[v]) {
                vis[v] = true;
                q.push(v);
            }
        }
    }

    return ans;
};